@modelstatus/cli 0.1.85 → 0.1.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelstatus/cli",
-  "version": "0.1.85",
+  "version": "0.1.87",
   "description": "Track which AI models you use, where, and never get surprised by a retirement. Free offline model-health for any repo (mm status), browser sign-in for cloud inventory + alerts.",
   "keywords": [
     "llm",
@@ -22,7 +22,8 @@
   ],
   "homepage": "https://llmstatus.ai",
   "bugs": {
-    "email": "it@llmstatus.ai"
+    "url": "https://github.com/randomartifact/llm-status/issues",
+    "email": "hi@llmstatus.ai"
   },
   "author": "LLM Status <it@llmstatus.ai>",
   "license": "MIT",
@@ -51,5 +52,9 @@
   },
   "devDependencies": {
     "ink-testing-library": "^4.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/randomartifact/llm-status.git"
   }
 }

package/src/api.js

@@ -1,14 +1,35 @@
 /** Thin client for the LLM Status / Model Manager public API (/api/v1). */
+
+// Per-request cap. Without one, a connection that stalls after the TCP accept
+// (captive portal, blackholing proxy) holds a command for undici's ~5-minute
+// default — or forever if the server dribbles bytes. Uploads get a longer
+// leash (big inventories on slow links). Overridable for tests.
+const timeoutMs = () => Number(process.env.MM_API_TIMEOUT_MS) || 15_000;
+const uploadTimeoutMs = () => Number(process.env.MM_API_UPLOAD_TIMEOUT_MS) || Number(process.env.MM_API_TIMEOUT_MS) || 60_000;
+
+const isTimeout = (e) => e?.name === "TimeoutError" || e?.name === "AbortError" || e?.code === "ABORT_ERR" || e?.cause?.name === "TimeoutError";
+
 export function createClient({ apiBase, apiKey }) {
-  async function req(method, pathname, body) {
-    const res = await fetch(`${apiBase}/api/v1${pathname}`, {
-      method,
-      headers: {
-        ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}),
-        ...(body ? { "content-type": "application/json" } : {}),
-      },
-      body: body ? JSON.stringify(body) : undefined,
-    });
+  async function req(method, pathname, body, { timeout = timeoutMs() } = {}) {
+    let res;
+    try {
+      res = await fetch(`${apiBase}/api/v1${pathname}`, {
+        method,
+        headers: {
+          ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}),
+          ...(body ? { "content-type": "application/json" } : {}),
+        },
+        body: body ? JSON.stringify(body) : undefined,
+        signal: AbortSignal.timeout(timeout),
+      });
+    } catch (e) {
+      if (isTimeout(e)) {
+        const err = new Error(`request timed out — check your network (${method} ${pathname} @ ${apiBase})`);
+        err.code = "ETIMEDOUT";
+        throw err;
+      }
+      throw e;
+    }
     const text = await res.text();
     let data;
     try {
@@ -18,7 +39,16 @@ export function createClient({ apiBase, apiKey }) {
     }
     if (!res.ok) {
       const msg = data?.error?.message || data?.message || `HTTP ${res.status}`;
-      const err = new Error(`${method} ${pathname} → ${msg}`);
+      // Auth failures get a re-login hint instead of a raw endpoint error —
+      // a revoked/rotated key is the most common cloud failure. 403 (valid key,
+      // insufficient scope/permissions) keeps the server's explanation.
+      const err = new Error(
+        res.status === 401
+          ? "API key invalid or expired — run `mm login` (or pass --key)"
+          : res.status === 403
+            ? `${msg} — run \`mm login\` to sign in with a different key`
+            : `${method} ${pathname} → ${msg}`,
+      );
       err.status = res.status;
       err.code = data?.error?.code;
       err.body = data;
@@ -62,7 +92,7 @@ export function createClient({ apiBase, apiKey }) {
     patchUsage: (id, body) => req("PATCH", `/usages/${id}`, body),
     deleteUsage: (id) => req("DELETE", `/usages/${id}`),
     linkUsage: (id, modelId) => req("POST", `/usages/${id}/link`, { model_id: modelId }),
-    bulkUpload: (projectId, usages) => req("POST", "/usages/bulk", { project_id: projectId, usages }),
+    bulkUpload: (projectId, usages) => req("POST", "/usages/bulk", { project_id: projectId, usages }, { timeout: uploadTimeoutMs() }),
     // Clear inventory: all usages, or `{ all: true }` to also wipe projects + rules + feed.
     clearUsages: ({ all = false, project } = {}) => req("DELETE", `/usages${qs({ all: all ? "true" : undefined, project_id: project })}`),
 

package/src/changelog-data.js

@@ -1,6 +1,29 @@
 /* GENERATED by scripts/gen-changelog.mjs from apps/web/lib/changelog.json — do not edit.
  * Release notes baked into the binary (in-TUI + the on-load what's-new card). */
 export const CHANGELOG = [
+  {
+    "version": "0.1.87",
+    "date": "2026-07-07",
+    "title": "Hardening pass: 40 fixes from an adversarial audit",
+    "items": [
+      "`mm fix` now writes the provider’s real model id (`gpt-5.5`), not the registry’s dash-form slug (`gpt-5-5`) — 59 of 85 replacement targets were affected. It also fixes everything the scanner detects (Bedrock ARNs, dated variants, mixed case), preserves your file’s line endings, and refuses to touch files that aren’t valid UTF-8.",
+      "The CI gate can’t pass by accident anymore: `--fail-on=retiring` (equals-style flags) now parses, a typo’d `--sources` or a path that doesn’t exist is a hard error instead of a silent green build, and withdrawn models fail the gate like retired ones. Unknown flags error out instead of being ignored.",
+      "`mm scan --dry-run` is fully local — no account needed, nothing sent anywhere.",
+      "Every network call has a timeout: a stalled CDN or API can’t hang a command for minutes. Failed self-updates back off instead of re-downloading each run, and self-update works on Windows.",
+      "Vendor CLI failures (aws, vercel, supabase…) warn instead of silently reporting a clean scan. `.github/workflows` files are scanned now, and `--vercel-project` verifies the linked project instead of relabeling output.",
+      "Telemetry no longer includes your working directory path — anonymous event names only, as documented.",
+      "TUI: long alerts lists scroll properly (keys can’t act on an off-screen rule, delete asks first), the arcade game can’t strand your terminal or undo a sign-in, and checkout polling stops when you quit."
+    ]
+  },
+  {
+    "version": "0.1.86",
+    "date": "2026-06-16",
+    "title": "Search the What's New feed",
+    "items": [
+      "The What's New tab now has `/` search, like Scan and Inventory. Filter the registry feed, alerts, fixes, and releases by typing — e.g. `deprecated` to see just the deprecations, or a model or provider name to jump to a specific change.",
+      "Press `/` to start filtering, `esc` to clear; the count of matches shows as you type."
+    ]
+  },
   {
     "version": "0.1.85",
     "date": "2026-06-14",

package/src/ci.js

@@ -9,10 +9,14 @@ import { getRegistry } from "./registry/fetch.js";
 import { resolveLocal, computeHealth } from "./registry/local.js";
 import { collectFrom } from "./sources/index.js";
 
-export const HEALTH_RANK = { ok: 0, deprecating: 1, retiring: 2, retired: 3 };
+// "withdrawn" (the provider already pulled the model) is as dead as retired —
+// same rank, mirroring tui/scan-stream.js — so it fails every threshold except
+// "none". Omitting it here once meant `undefined >= threshold` and withdrawn
+// models could NEVER fail the build.
+export const HEALTH_RANK = { ok: 0, deprecating: 1, retiring: 2, retired: 3, withdrawn: 3 };
 // `--fail-on` threshold → the minimum health rank that fails the build.
 export const FAIL_THRESHOLD = { none: 99, deprecating: 1, retiring: 2, retired: 3 };
-const BADGE = { ok: "🟢", deprecating: "🟡", retiring: "🟠", retired: "🔴" };
+const BADGE = { ok: "🟢", deprecating: "🟡", retiring: "🟠", retired: "🔴", withdrawn: "⛔" };
 
 /** Evaluate `dir` and return { findings, failing, threshold, failOn, counts, snapshot }.
  * `findings` are per-(model, location) entries with health worse than ok. */
@@ -54,7 +58,7 @@ export async function evaluateCi({ dir, sources = ["filesystem"], explicit = new
   }
   findings.sort((a, b) => HEALTH_RANK[b.health] - HEALTH_RANK[a.health] || String(a.retires || "9999").localeCompare(String(b.retires || "9999")));
 
-  const counts = { ok: 0, deprecating: 0, retiring: 0, retired: 0 };
+  const counts = { ok: 0, deprecating: 0, retiring: 0, retired: 0, withdrawn: 0 };
   for (const f of findings) counts[f.health]++;
   const failing = findings.filter((f) => HEALTH_RANK[f.health] >= threshold);
   return { snapshot, candidates, findings, failing, threshold, failOn, counts };
@@ -126,7 +130,7 @@ export function annotationLines(findings, threshold) {
 export function summaryMarkdown(findings, { failing, failOn } = {}) {
   const lines = ["## LLM Status — model lifecycle check", ""];
   if (!findings.length) {
-    lines.push("✅ No deprecated, retiring, or retired AI models found.");
+    lines.push("✅ No deprecated, retiring, retired, or withdrawn AI models found.");
     return lines.join("\n") + "\n";
   }
   const fc = failing ? failing.length : 0;

package/src/detect/core.js

@@ -16,21 +16,22 @@ function cleanGeneric(s) {
 
 /** A char is part of a model token if it's alnum or one of - _ . / : (slug-ish).
  * Mirrors the server PR scanner (apps/web/lib/github/scan-pr.ts) so the CLI and
- * the GitHub check agree on what counts as a boundary. */
-function isTokenChar(ch) {
+ * the GitHub check agree on what counts as a boundary. Exported so fix.js keeps
+ * its rewrite boundaries in lockstep with detection. */
+export function isTokenChar(ch) {
   return /[A-Za-z0-9._/:-]/.test(ch);
 }
 
 // Provider prefixes legitimately precede an id ("anthropic.claude-…", "ft:gpt-…",
 // "us.anthropic.…", "openrouter/…"), so '.' ':' '/' on the LEFT is still a boundary.
-function isPrefixSep(ch) {
+export function isPrefixSep(ch) {
   return ch === "." || ch === ":" || ch === "/";
 }
 // Known model-id SUFFIXES seen in real configs: Bedrock ':0'/'-v1', dated
 // '-20250514' snapshots, '@version'. The remainder starting with one is still a
 // boundary — so "claude-opus-4-20250514" resolves inside a Bedrock ARN, while
 // "gpt-4" still does NOT match inside "gpt-4o". Kept identical to scan-pr.ts.
-const MODEL_SUFFIX = /^(:|-v[0-9]|-[0-9]{6,}|@)/;
+export const MODEL_SUFFIX = /^(:|-v[0-9]|-[0-9]{6,}|@)/;
 
 /** True when `term` occurs in `haystack` at a model-id boundary — tolerating
  * provider prefixes + known version/region/snapshot suffixes, but NOT a plain
@@ -135,8 +136,18 @@ export function detectInLine(line, compiled) {
     re.lastIndex = 0;
     let m;
     while ((m = re.exec(line))) {
-      const cand = cleanGeneric(m[0].toLowerCase());
-      if (looksLikeModel(cand)) found.add(cand);
+      // Left boundary — same rule as matchesAtBoundary. A token char right
+      // before the match means we're inside a longer identifier ("ChatGPT-4",
+      // "ngrok-2.3.40", "my-gpt-4-deployment"), not a model id; provider
+      // prefixes ('.' ':' '/') stay legal ("openai/gpt-4", "ft:gpt-4",
+      // "anthropic.claude-…"). Hyphen/underscore-joined prefixes are treated
+      // as compound identifiers (resource/deployment names), matching the
+      // exact-string matcher. (scan-pr.ts should mirror this — see web repo.)
+      const before = m.index > 0 ? line[m.index - 1] : "";
+      if (!before || !isTokenChar(before) || isPrefixSep(before)) {
+        const cand = cleanGeneric(m[0].toLowerCase());
+        if (looksLikeModel(cand)) found.add(cand);
+      }
       if (re.lastIndex === m.index) re.lastIndex++;
     }
   }

package/src/fix.js

@@ -9,15 +9,23 @@
  *  - Replace ONLY on the recorded line. If the string is no longer there (file
  *    changed since the scan), the ref is reported "stale" and skipped — never
  *    guess. A rescan refreshes the locations.
- *  - Boundary-aware matching: "gpt-4" must never rewrite inside "gpt-4o" /
- *    "gpt-4-turbo". A model-id character ([A-Za-z0-9._-]) on either side of the
- *    match blocks it.
+ *  - Boundary-aware matching in LOCKSTEP with detect/core.js (same predicates,
+ *    same case-insensitivity): "gpt-4" must never rewrite inside "gpt-4o" /
+ *    "gpt-4-turbo", but provider prefixes ("anthropic.claude-…", "openai/…")
+ *    are fine on the left — exactly what the scan matched, fix can rewrite.
+ *  - Version-pinned occurrences ("claude-3-sonnet@20240229", Bedrock "-v1:0",
+ *    ft ":acme", template "-${ver}") are NEVER base-swapped — the old model's
+ *    pin glued to the new id is a nonexistent id. They skip with an explicit
+ *    "pinned variant — review manually" note.
+ *  - Never corrupt bytes: non-UTF-8 files are skipped loudly, and every line
+ *    keeps its own \n / \r\n ending (one stray CRLF never converts the file).
  *  - Style-preserving replacement: if the code says "openai/gpt-4" the new id
  *    keeps the provider prefix; if it says "gpt-4" it stays bare.
  */
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { isTokenChar, isPrefixSep, MODEL_SUFFIX } from "./detect/core.js";
 
 /**
  * Follow a replacement chain to the first CURRENT model. Replacements can
@@ -25,6 +33,12 @@ import path from "node:path";
  * rewriting to a dying model just means fixing twice — land on the live one.
  * `getModel(slug)` → model|null; `isCurrent(model)` → bool. Cycle-guarded;
  * unknown slugs end the walk (best known answer wins).
+ *
+ * Returns the WRITE-FORM of the target — "provider/canonical_id" when the
+ * model is known (e.g. "openai/gpt-5.5"), else the registry slug. Registry
+ * slugs dash-encode dots ("openai/gpt-5-5"), and providers reject the slug
+ * form ("gpt-5-5" 404s where the API id is "gpt-5.5") — canonical_id is the
+ * provider's real API id. styleReplacement() derives both styles from it.
  */
 export function terminalReplacement(startSlug, getModel, isCurrent) {
   let cur = startSlug;
@@ -35,7 +49,14 @@ export function terminalReplacement(startSlug, getModel, isCurrent) {
     if (!m || isCurrent(m) || !m.replacement_slug) break;
     cur = m.replacement_slug;
   }
-  return cur || startSlug;
+  const slug = cur || startSlug;
+  const m = getModel(slug);
+  if (m?.canonical_id) {
+    const provider = m.provider_slug
+      || (typeof m.slug === "string" && m.slug.includes("/") ? m.slug.slice(0, m.slug.indexOf("/")) : "");
+    return provider ? `${provider}/${m.canonical_id}` : m.canonical_id;
+  }
+  return slug; // no canonical known — the slug is the best answer we have
 }
 
 /* ------------------------------------------------------------ fix history */
@@ -73,43 +94,94 @@ export function readFixes() {
   }
 }
 
-/** The string to write into the file: the replacement slug, styled to match how
- * the old id was written (provider-prefixed vs bare). */
-export function styleReplacement(oldStr, replacementSlug) {
-  if (!replacementSlug) return null;
-  const i = replacementSlug.indexOf("/");
-  const bare = i >= 0 ? replacementSlug.slice(i + 1) : replacementSlug;
-  return oldStr.includes("/") ? replacementSlug : bare;
+/** The string to write into the file, styled to match how the old id was
+ * written (provider-prefixed vs bare). `replacement` is terminalReplacement's
+ * write-form ("provider/canonical_id", e.g. "openai/gpt-5.5") — bare originals
+ * get the canonical id after the first "/", prefixed originals the whole thing.
+ * (A plain registry slug still styles correctly, just without canonical ids.) */
+export function styleReplacement(oldStr, replacement) {
+  if (!replacement) return null;
+  const i = replacement.indexOf("/");
+  const bare = i >= 0 ? replacement.slice(i + 1) : replacement;
+  return oldStr.includes("/") ? replacement : bare;
 }
 
-const BOUND = "[A-Za-z0-9._-]";
-const escRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-
-/** Boundary-safe replace of every occurrence of `from` in one line of text.
- * Returns { out, n } — the rewritten line and how many occurrences changed. */
+/** Boundary-safe replace of every occurrence of `from` in one line of text,
+ * with the SAME boundary semantics (and case-insensitivity) as detection —
+ * whatever the scan matched, this can find. Occurrences whose right context is
+ * a version pin of the OLD model ("@20240229", "-v1:0", ":acme", "-${ver}")
+ * are never base-swapped (the old pin glued to the new id is a nonexistent
+ * id); they're returned in `pinned` so callers can report them honestly.
+ * Returns { out, n, pinned } — the rewritten line, how many occurrences
+ * changed, and the pinned occurrences (with a bit of right context). */
 export function replaceOnLine(lineText, from, to) {
-  const re = new RegExp(`(?<!${BOUND})${escRe(from)}(?!${BOUND})`, "g");
+  const lower = lineText.toLowerCase();
+  const f = String(from ?? "").toLowerCase();
+  let out = "";
+  let last = 0;
   let n = 0;
-  const out = lineText.replace(re, () => {
-    n += 1;
-    return to;
-  });
-  return { out, n };
+  const pinned = [];
+  let at = 0;
+  while (f && (at = lower.indexOf(f, at)) >= 0) {
+    const before = at > 0 ? lower[at - 1] : "";
+    if (before && isTokenChar(before) && !isPrefixSep(before)) {
+      at += 1; // inside a longer identifier — a later occurrence may be clean
+      continue;
+    }
+    const rest = lower.slice(at + f.length);
+    const after = rest[0] ?? "";
+    // Trailing separators the generic detector trims ("claude-3-5-sonnet-${ver}",
+    // "gpt-4."): a [-._]+ run NOT followed by more token chars.
+    const trimmedTail = rest.replace(/^[-._]+/, "");
+    const isPinned =
+      (after === "@" && /^@[a-z0-9]/.test(rest)) || // Vertex-style @-pin
+      (isTokenChar(after) && MODEL_SUFFIX.test(rest)) || // ':0' / '-v1' / '-20240229'
+      (/^[-._]/.test(rest) && !(trimmedTail && isTokenChar(trimmedTail[0])));
+    if (isPinned) {
+      const ctx = /^[^\s"'`]{0,16}/.exec(lineText.slice(at + f.length))?.[0] ?? "";
+      pinned.push(lineText.slice(at, at + f.length) + ctx);
+      at += f.length;
+      continue;
+    }
+    if (after === "" || !isTokenChar(after)) {
+      out += lineText.slice(last, at) + to;
+      last = at + f.length;
+      n += 1;
+      at += f.length;
+      continue;
+    }
+    at += 1; // embedded in a longer id (gpt-4 in gpt-4o) — keep looking
+  }
+  return { out: out + lineText.slice(last), n, pinned };
+}
+
+/** The skip reason for a line where nothing was rewritten. */
+function skipError(pinned) {
+  return pinned.length
+    ? `pinned variant "${pinned[0]}" — review manually`
+    : "string not on that line anymore — rescan";
+}
+
+/** Decode a buffer as UTF-8 only if it round-trips byte-for-byte — otherwise
+ * null (writing a lossy decode back would corrupt the file: 0xE9 → U+FFFD). */
+function decodeUtf8Strict(buf) {
+  const text = buf.toString("utf8");
+  return Buffer.from(text, "utf8").equals(buf) ? text : null;
 }
 
 /**
  * Build fix plans from scan refs. `refs` = [{ model_string, source_path,
- * source_line }] (the shape the scanner emits); `replacementSlug` is the
- * registry replacement for the model those refs belong to. Refs without a real
- * file path (integration scheme labels like vercel://) are skipped — only
- * filesystem refs are rewritable.
+ * source_line }] (the shape the scanner emits); `replacement` is
+ * terminalReplacement's write-form ("provider/canonical_id") for the model
+ * those refs belong to. Refs without a real file path (integration scheme
+ * labels like vercel://) are skipped — only filesystem refs are rewritable.
  */
-export function planFixes(refs, replacementSlug) {
+export function planFixes(refs, replacement) {
   const plans = [];
   const seen = new Set();
   for (const r of refs || []) {
     if (!r?.source_path || !r.source_line || !r.model_string) continue;
-    const to = styleReplacement(r.model_string, replacementSlug);
+    const to = styleReplacement(r.model_string, replacement);
     if (!to || to === r.model_string) continue;
     const key = `${r.source_path}:${r.source_line}:${r.model_string}`;
     if (seen.has(key)) continue;
@@ -133,24 +205,29 @@ export function planFixes(refs, replacementSlug) {
 export function previewFixes(dir, plans) {
   const previews = [];
   const stale = [];
-  const cache = new Map(); // file -> lines[] | null
+  const cache = new Map(); // file -> { lines } | { error } | {}
   for (const p of plans) {
     if (!cache.has(p.file)) {
+      let entry = {}; // unreadable → "file or line missing" below
       try {
-        cache.set(p.file, fs.readFileSync(path.resolve(dir, p.file), "utf8").split(/\r?\n/));
-      } catch {
-        cache.set(p.file, null);
-      }
+        const text = decodeUtf8Strict(fs.readFileSync(path.resolve(dir, p.file)));
+        entry = text == null ? { error: "not valid UTF-8 — skipped" } : { lines: text.split(/\r?\n/) };
+      } catch { /* keep {} */ }
+      cache.set(p.file, entry);
     }
-    const lines = cache.get(p.file);
-    const before = lines?.[p.line - 1];
+    const ent = cache.get(p.file);
+    if (ent.error) {
+      stale.push({ ...p, error: ent.error });
+      continue;
+    }
+    const before = ent.lines?.[p.line - 1];
     if (before == null) {
       stale.push({ ...p, error: "file or line missing — rescan" });
       continue;
     }
-    const { out, n } = replaceOnLine(before, p.from, p.to);
+    const { out, n, pinned } = replaceOnLine(before, p.from, p.to);
     if (n === 0) {
-      stale.push({ ...p, error: "string not on that line anymore — rescan" });
+      stale.push({ ...p, error: skipError(pinned) });
       continue;
     }
     previews.push({ ...p, before, after: out });
@@ -177,13 +254,20 @@ export function applyFixes(dir, plans) {
     const abs = path.resolve(dir, file);
     let text;
     try {
-      text = fs.readFileSync(abs, "utf8");
+      text = decodeUtf8Strict(fs.readFileSync(abs));
+      if (text == null) {
+        // A lossy decode written back would corrupt every non-UTF-8 byte in
+        // the file (0xE9 → U+FFFD) — refuse loudly instead.
+        for (const p of filePlans) failed.push({ ...p, error: "not valid UTF-8 — skipped" });
+        continue;
+      }
     } catch (e) {
       for (const p of filePlans) failed.push({ ...p, error: e.code === "ENOENT" ? "file not found" : e.message });
       continue;
     }
-    const eol = text.includes("\r\n") ? "\r\n" : "\n";
-    const lines = text.split(/\r?\n/);
+    // Split KEEPING each line's own terminator so untouched lines round-trip
+    // byte-identical — one stray CRLF line must never convert the whole file.
+    const lines = text.split(/(?<=\n)/);
     let dirty = false;
     for (const p of filePlans) {
       const idx = p.line - 1;
@@ -191,19 +275,21 @@ export function applyFixes(dir, plans) {
         stale.push({ ...p, error: "line out of range — rescan" });
         continue;
       }
-      const before = lines[idx];
-      const { out, n } = replaceOnLine(before, p.from, p.to);
+      const raw = lines[idx];
+      const nl = /\r?\n$/.exec(raw)?.[0] ?? "";
+      const body = nl ? raw.slice(0, -nl.length) : raw;
+      const { out, n, pinned } = replaceOnLine(body, p.from, p.to);
       if (n === 0) {
-        stale.push({ ...p, error: "string not on that line anymore — rescan" });
+        stale.push({ ...p, error: skipError(pinned) });
         continue;
       }
-      lines[idx] = out;
+      lines[idx] = out + nl;
       dirty = true;
-      applied.push({ ...p, count: n, before, after: out });
+      applied.push({ ...p, count: n, before: body, after: out });
     }
     if (dirty) {
       try {
-        fs.writeFileSync(abs, lines.join(eol));
+        fs.writeFileSync(abs, lines.join(""));
       } catch (e) {
         // Roll the bookkeeping back: everything in this file actually failed.
         for (let i = applied.length - 1; i >= 0; i--) {