From a4f5eeeee7489e3935810bb9dd03005ef74f6056 Mon Sep 17 00:00:00 2001 From: Divide-By-0 Date: Sat, 3 Oct 2026 19:20:03 -0700 Subject: [PATCH 1/2] feat(verify): collapse long redactions; CLI reveals each passage once (plain-text copy) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Verify page: a redacted stretch of 240+ hidden characters (one long run, or many fully hidden lines with revealed line breaks) shows as one row '⋯ 9,139 redacted characters (~115 lines) ⋯ show' that expands on click. CLI: the preview/verify output merges 3+ fully redacted lines the same way. CLI --reveal: in multipart/alternative mail, a passage found in the plain-text part is no longer also revealed inside the text/html part (--reveal-all-parts restores that). SKILL.md: reveal each passage once, in its most human-readable copy. Co-Authored-By: Claude Opus 5.5 --- skills/redacted-email-proof/SKILL.md | 15 +++ .../redacted-email-proof/scripts/redacted.mjs | 51 ++++++++- src/components/MaskedText.tsx | 105 +++++++++--------- src/utils/maskedRuns.ts | 64 +++++++++++ tests/masked-runs.test.ts | 60 ++++++++++ 5 files changed, 238 insertions(+), 57 deletions(-) create mode 100644 src/utils/maskedRuns.ts create mode 100644 tests/masked-runs.test.ts diff --git a/skills/redacted-email-proof/SKILL.md b/skills/redacted-email-proof/SKILL.md index 25ce412..15c96d1 100644 --- a/skills/redacted-email-proof/SKILL.md +++ b/skills/redacted-email-proof/SKILL.md @@ -97,6 +97,21 @@ $R prove email.eml --dry-run \ command **fails if a hide target isn't found** (use `--allow-missing` to override). Treat that failure as a signal: the text may be encoded differently, so read the `inspect` output. - Hides always win over reveals. +- **Reveal each passage once, in its most readable copy.** Most HTML email is + `multipart/alternative`: the same message appears as a `text/plain` part and again as a + `text/html` part. Revealing a passage in both publishes it twice, the second time wrapped in + tags and entities (`can't`, `
`), which is noisy and exposes the HTML layout around it. + - The CLI handles the common case: when a `--reveal` matches the plain-text part, its copies in + the HTML part stay hidden and a warning says so. Pass `--reveal-all-parts` only if the user + wants both. + - When choosing what to reveal, read `inspect`'s body and pick the plain-text wording. Prefer + `--reveal` phrases over broad `--reveal-regex` patterns that also catch the HTML copy. + - If two passages are near-duplicates (a quoted reply, a signature repeated at the bottom, a + plain and an HTML rendering), reveal only the one a person would read: plain text over HTML, + the original over the quoted copy. + - If the text exists *only* in the HTML part, reveal it there, and keep it to the text itself: + don't widen the reveal to the surrounding tags. + - Check the preview: the same sentence should not appear twice. - **Show the preview to the user and get their OK before proving.** Everything not shown as █ in the preview becomes public if the proof is published. diff --git a/skills/redacted-email-proof/scripts/redacted.mjs b/skills/redacted-email-proof/scripts/redacted.mjs index 4cebae8..c6d6521 100755 --- a/skills/redacted-email-proof/scripts/redacted.mjs +++ b/skills/redacted-email-proof/scripts/redacted.mjs @@ -114,6 +114,8 @@ Mask options for prove (hidden bytes become 0x00 in the proof and show as ${BLOC --reveal With --hide-body: re-reveal occurrences of this text. Repeatable. Hides always win over reveals. --reveal-regex Regex form of --reveal. + --reveal-all-parts Also reveal matches inside the text/html part when the text is in the + plain-text part too (default: reveal only the plain-text copy). --reveal-dkim-hashes Keep DKIM-Signature bh= and b= visible (hidden by default because bh= lets anyone confirm a guess of a fully hidden body). --allow-missing Don't fail when a --hide target is not found. @@ -560,6 +562,21 @@ function headerLines(h) { return lines.filter((l) => l.name); } +// Byte ranges of text/html MIME parts in a raw body ([start, end) of each part's content). +// Parts are found from their delimiter lines ("--"), so nested multiparts work too. +export function htmlPartRanges(body) { + const delims = [...body.matchAll(/(?:^|\r\n)--[^\r\n\s]{1,200}(?=\r\n|$)/g)].map((m) => m.index + (m[0].startsWith("\r\n") ? 2 : 0)); + const out = []; + for (let i = 0; i < delims.length; i++) { + const partStart = body.indexOf("\r\n", delims[i]) + 2; + const headersEnd = body.indexOf("\r\n\r\n", partStart); + const partEnd = i + 1 < delims.length ? delims[i + 1] : body.length; + if (partStart < 2 || headersEnd < 0 || headersEnd > partEnd) continue; + if (/^content-type:\s*text\/html/im.test(body.slice(partStart, headersEnd))) out.push([headersEnd + 4, partEnd]); + } + return out; +} + export function buildMasks(dkim, opts) { const h = lat1(dkim.headers); const b = lat1(dkim.body); @@ -600,11 +617,28 @@ export function buildMasks(dkim, opts) { } // reveals first, hides last: hides always win + // REASON: multipart/alternative mail carries the same message twice, as text/plain and as + // text/html. Revealing a sentence in both publishes it twice, the second time wrapped in markup + // and entities ("can't"), which is noisy and reveals the HTML structure around it for nothing. + // So when a reveal matches outside the HTML part, its copies inside HTML parts stay hidden + // (--reveal-all-parts keeps both). Text that only exists in the HTML part is still revealed there. + const html = htmlPartRanges(b); + const inHtml = (k) => html.some(([lo, hi]) => k >= lo && k < hi); + const reveal = (label, matcher) => { + const plain = applyMatches(bodyMask, b, matcher, 1, opts["reveal-all-parts"] || !html.length ? {} : { region: (k) => !inHtml(k) }); + if (plain && html.length && !opts["reveal-all-parts"]) { + if (applyMatches(new Array(b.length), b, matcher, 1, { region: inHtml })) { + warnings.push(`${label}: also in the HTML part; revealed only in the plain-text part (--reveal-all-parts reveals both)`); + } + return plain; + } + return plain || applyMatches(bodyMask, b, matcher, 1); + }; for (const t of [].concat(opts.reveal || [])) { - if (!applyMatches(bodyMask, b, literalMatcher(needleLatin1(t)), 1)) warnings.push(`--reveal "${t}" not found in body`); + if (!reveal(`--reveal "${t}"`, literalMatcher(needleLatin1(t)))) warnings.push(`--reveal "${t}" not found in body`); } for (const r of [].concat(opts["reveal-regex"] || [])) { - if (!applyMatches(bodyMask, b, regexMatcher(r), 1)) warnings.push(`--reveal-regex /${r}/ matched nothing in body`); + if (!reveal(`--reveal-regex /${r}/`, regexMatcher(r))) warnings.push(`--reveal-regex /${r}/ matched nothing in body`); } // header name bytes are structural; only hide inside values @@ -623,7 +657,17 @@ export function buildMasks(dkim, opts) { // Long hidden runs (usually whole hidden lines, newlines included) become one "█×N" marker so the // preview stays readable in a terminal or an agent's context window. -const compact = (s) => s.replace(new RegExp(`${BLOCK}{12,}`, "g"), (m) => `${BLOCK}×${m.length}`); +// Shorten redactions for the terminal: a long run of blocks becomes "█×N", and 3+ consecutive +// lines that are entirely redacted become one "█ ⋯ N redacted characters (L lines) ⋯" line +// (same idea as the verify page's collapsed redactions, src/utils/maskedRuns.ts). +export const compact = (s) => + s + .replace(new RegExp(`${BLOCK}{12,}`, "g"), (m) => `${BLOCK}×${m.length}`) + .replace(new RegExp(`(?:^[ \\t]*${BLOCK}+(?:×(\\d+))?[ \\t]*(?:\\n|$)){3,}`, "gm"), (m) => { + const lines = m.split("\n").filter((l) => l.trim()); + const n = lines.reduce((sum, l) => sum + (Number(/×(\d+)/.exec(l)?.[1]) || l.trim().length), 0); + return `${BLOCK} ⋯ ${n.toLocaleString("en-US")} redacted characters (${lines.length} lines) ⋯${m.endsWith("\n") ? "\n" : ""}`; + }); function renderDecoded(s, mask) { const bytes = Buffer.from(s, "latin1").map((v, i) => (mask[i] ? v : 0)); @@ -1271,6 +1315,7 @@ if (isMain) { reveal: { type: "string", multiple: true }, "reveal-regex": { type: "string", multiple: true }, "reveal-dkim-hashes": { type: "boolean" }, + "reveal-all-parts": { type: "boolean" }, "allow-missing": { type: "boolean" }, domain: { type: "string" }, "dry-run": { type: "boolean" }, diff --git a/src/components/MaskedText.tsx b/src/components/MaskedText.tsx index bf1ad9e..85d7d1f 100644 --- a/src/components/MaskedText.tsx +++ b/src/components/MaskedText.tsx @@ -1,67 +1,64 @@ +import { useState } from 'react'; +import { maskedSegments } from '../utils/maskedRuns'; + interface MaskedTextProps { text: string; className?: string; } -/** - * Component that displays text with null bytes rendered as black blocks - * - * Null bytes (0x00) in the text are displayed as black rectangles, - * representing masked/redacted content from the ZK proof. - */ -export default function MaskedText({ text, className = '' }: MaskedTextProps) { - // Split text into segments: regular text and null byte sequences - const segments: { type: 'text' | 'masked'; content: string }[] = []; - let currentSegment = ''; - let inMaskedSection = false; - - for (let i = 0; i < text.length; i++) { - const char = text[i]; - const isNull = char === '\x00'; - - if (isNull !== inMaskedSection) { - // Transition between masked and unmasked - if (currentSegment) { - segments.push({ - type: inMaskedSection ? 'masked' : 'text', - content: currentSegment, - }); - } - currentSegment = char; - inMaskedSection = isNull; - } else { - currentSegment += char; - } - } +const Blocks = ({ count }: { count: number }) => ( + + {'█'.repeat(count)} + +); - // Push final segment - if (currentSegment) { - segments.push({ - type: inMaskedSection ? 'masked' : 'text', - content: currentSegment, - }); +/** A long redacted stretch, collapsed to one row; click to show every block. */ +function CollapsedRedaction({ content, hidden, lines }: { content: string; hidden: number; lines: number }) { + const [open, setOpen] = useState(false); + if (open) { + return ( + <> + {content.split(/(\0+)/).map((part, i) => + part.startsWith('\0') ? : {part} + )} + + + ); } + return ( + + ); +} +/** + * Text with null bytes (0x00, masked content from the ZK proof) rendered as black blocks. + * Long redacted stretches are collapsed to one row (see utils/maskedRuns.ts). + */ +export default function MaskedText({ text, className = '' }: MaskedTextProps) { return ( - {segments.map((segment, idx) => { - if (segment.type === 'masked') { - // Render black blocks for masked content - // Each null byte becomes one block character - return ( - - {'\u2588'.repeat(segment.content.length)} - - ); - } + {maskedSegments(text).map((segment, idx) => { + if (segment.type === 'collapsed') return ; + if (segment.type === 'masked') return ; return {segment.content}; })} diff --git a/src/utils/maskedRuns.ts b/src/utils/maskedRuns.ts new file mode 100644 index 0000000..d86d3da --- /dev/null +++ b/src/utils/maskedRuns.ts @@ -0,0 +1,64 @@ +/** + * Split masked text (0x00 = hidden byte) into display segments, collapsing long redacted stretches. + * + * REASON: a proof that hides most of a body shows tens of thousands of █ blocks, which bury the + * few revealed sentences. A redacted stretch is either + * - one long run of 0x00 (the hidden newlines are hidden too, so its "lines" are only wrapping), or + * - many fully hidden lines whose line breaks were revealed: 0x00 runs separated by whitespace only. + * Both become one "collapsed" segment the page can show as "⋯ N redacted characters (~L lines) ⋯" + * with a toggle to expand. Display only: the proof and the decoded bytes are unchanged. + */ +export type MaskedSegment = + | { type: "text"; content: string } + | { type: "masked"; content: string } + /** a long redacted stretch: `content` is the original text of the stretch (hidden bytes and the whitespace between them) */ + | { type: "collapsed"; content: string; hidden: number; lines: number }; + +/** Collapse redacted stretches with at least this many hidden characters (~3 wrapped lines). */ +export const COLLAPSE_MIN_HIDDEN = 240; +/** Characters per line used to estimate the line count of a run whose newlines are hidden. */ +export const CHARS_PER_LINE = 80; + +export function maskedSegments(text: string, minHidden = COLLAPSE_MIN_HIDDEN): MaskedSegment[] { + // 1. plain runs: text vs 0x00 + const runs: { masked: boolean; content: string }[] = []; + for (const m of text.matchAll(/\0+|[^\0]+/g)) runs.push({ masked: m[0][0] === "\0", content: m[0] }); + + // 2. group masked runs that are separated only by whitespace (revealed line breaks between + // fully hidden lines) into one stretch + const out: MaskedSegment[] = []; + for (let i = 0; i < runs.length; ) { + if (!runs[i].masked) { + out.push({ type: "text", content: runs[i].content }); + i++; + continue; + } + let j = i; + let hidden = 0; + let content = ""; + let breaks = 0; + // extend while the next text run is whitespace only and is followed by another masked run + for (;;) { + hidden += runs[j].content.length; + content += runs[j].content; + const gap = runs[j + 1]; + if (gap && !gap.masked && /^\s+$/.test(gap.content) && runs[j + 2]?.masked) { + content += gap.content; + breaks += (gap.content.match(/\n/g) ?? []).length; + j += 2; + continue; + } + break; + } + if (hidden >= minHidden) { + // Revealed line breaks give exact lines; hidden newlines don't, so estimate from length. + const lines = Math.max(breaks + 1, Math.ceil(hidden / CHARS_PER_LINE)); + out.push({ type: "collapsed", content, hidden, lines }); + } else { + // short: keep the original runs as they were + for (let k = i; k <= j; k++) out.push({ type: runs[k].masked ? "masked" : "text", content: runs[k].content }); + } + i = j + 1; + } + return out; +} diff --git a/tests/masked-runs.test.ts b/tests/masked-runs.test.ts new file mode 100644 index 0000000..80c68af --- /dev/null +++ b/tests/masked-runs.test.ts @@ -0,0 +1,60 @@ +/** Verify page: long redacted stretches collapse to one row (src/utils/maskedRuns.ts). */ +import { test } from "node:test"; +import assert from "node:assert/strict"; +import { maskedSegments } from "../src/utils/maskedRuns"; + +const H = (n: number) => "\0".repeat(n); + +test("one long hidden run (hidden newlines) collapses with an estimated line count", () => { + const segs = maskedSegments(`Hi${H(27430)}omissions.${H(10)}`); + assert.deepEqual(segs.map((s) => s.type), ["text", "collapsed", "text", "masked"]); + const c = segs[1] as Extract<(typeof segs)[number], { type: "collapsed" }>; + assert.equal(c.hidden, 27430); + assert.equal(c.lines, Math.ceil(27430 / 80)); +}); + +test("many fully hidden lines with revealed line breaks merge into one stretch with the exact line count", () => { + const lines = Array.from({ length: 111 }, () => H(70)).join("\r\n"); + const segs = maskedSegments(`Dear X,\r\n${lines}\r\nThanks`); + assert.deepEqual(segs.map((s) => s.type), ["text", "collapsed", "text"]); + const c = segs[1] as Extract<(typeof segs)[number], { type: "collapsed" }>; + assert.equal(c.hidden, 111 * 70); + assert.equal(c.lines, 111); + // nothing is lost: the collapsed stretch keeps the original bytes for "show" + assert.equal(segs.map((s) => s.content).join(""), `Dear X,\r\n${lines}\r\nThanks`); +}); + +test("short redactions and stretches broken by revealed words stay inline", () => { + assert.deepEqual(maskedSegments(`To: ${H(30)}\r\n`).map((s) => s.type), ["text", "masked", "text"]); + const segs = maskedSegments(`${H(200)} word ${H(200)}`); + assert.deepEqual(segs.map((s) => s.type), ["masked", "text", "masked"]); +}); + +test("CLI compact: long runs become █×N and 3+ fully redacted lines merge into one", async () => { + // @ts-expect-error - plain JS module without types + const { compact } = await import("../skills/redacted-email-proof/scripts/redacted.mjs"); + const B = "█"; + const lines = [...Array.from({ length: 110 }, () => B.repeat(70)), B.repeat(5)].join("\n"); + assert.equal(compact(`Dear X,\n${lines}\nThanks ${B.repeat(5)}\n`), `Dear X,\n${B} ⋯ 7,705 redacted characters (111 lines) ⋯\nThanks ${B.repeat(5)}\n`); + assert.equal(compact(`a\n${B.repeat(20)}\n${B.repeat(20)}\nb`), `a\n${B}×20\n${B}×20\nb`, "two lines stay as they are"); +}); + +test("CLI --reveal: text in both the plain and HTML parts is revealed only in the plain-text part", async () => { + // @ts-expect-error - plain JS module without types + const { buildMasks, htmlPartRanges } = await import("../skills/redacted-email-proof/scripts/redacted.mjs"); + const body = + "--b1\r\nContent-Type: text/plain; charset=utf-8\r\n\r\nWe can share the lab agreement.\r\n" + + "--b1\r\nContent-Type: text/html; charset=utf-8\r\n\r\n
We can share the lab agreement.

Only in html

\r\n--b1--\r\n"; + const dkim = { headers: Buffer.from("from:a@b.example\r\n"), body: Buffer.from(body) }; + const shown = (mask: number[]) => [...body].map((c, i) => (mask[i] ? c : "\0")).join("").replace(/\0+/g, "█"); + assert.equal(htmlPartRanges(body).length, 1); + + const m = buildMasks(dkim, { "hide-body": true, reveal: ["We can share the lab agreement.", "Only in html"] }); + assert.equal(shown(m.bodyMask).match(/We can share/g)?.length, 1, "revealed once"); + assert.ok(body.indexOf("We can share") === shown(m.bodyMask).indexOf("We can share") || shown(m.bodyMask).startsWith("█We can share"), "the plain-text copy"); + assert.match(shown(m.bodyMask), /Only in html/, "HTML-only text is still revealed"); + assert.ok(m.warnings.some((w: string) => /also in the HTML part/.test(w))); + + const all = buildMasks(dkim, { "hide-body": true, reveal: ["We can share the lab agreement."], "reveal-all-parts": true }); + assert.equal(shown(all.bodyMask).match(/We can share/g)?.length, 2, "--reveal-all-parts keeps both"); +}); From 6553cdaecc3cc2cddbd5f8fea3cc537070fe26da Mon Sep 17 00:00:00 2001 From: Divide-By-0 Date: Sat, 3 Oct 2026 19:23:13 -0700 Subject: [PATCH 2/2] fix(cli): dedupe reveals per match against real text/plain content Review findings: (1) one plain-text regex match suppressed unrelated HTML-only matches of the same regex; (2) anything outside text/html (MIME headers, attachments) counted as the 'plain-text copy', hiding the readable HTML occurrence. Now each HTML match is skipped only if the same matched text occurs inside text/plain part content. Tests for both. Co-Authored-By: Claude Opus 5.5 --- .../redacted-email-proof/scripts/redacted.mjs | 53 ++++++++++++++----- tests/masked-runs.test.ts | 28 +++++++++- 2 files changed, 66 insertions(+), 15 deletions(-) diff --git a/skills/redacted-email-proof/scripts/redacted.mjs b/skills/redacted-email-proof/scripts/redacted.mjs index c6d6521..6af3699 100755 --- a/skills/redacted-email-proof/scripts/redacted.mjs +++ b/skills/redacted-email-proof/scripts/redacted.mjs @@ -562,17 +562,33 @@ function headerLines(h) { return lines.filter((l) => l.name); } -// Byte ranges of text/html MIME parts in a raw body ([start, end) of each part's content). -// Parts are found from their delimiter lines ("--"), so nested multiparts work too. -export function htmlPartRanges(body) { +// Content byte ranges ([start, end)) of MIME parts of one media type (e.g. "text/html"), found +// from their delimiter lines ("--"), so nested multiparts work too. Part headers are +// excluded: only the content after each part's blank line counts. +export function mimePartRanges(body, type) { const delims = [...body.matchAll(/(?:^|\r\n)--[^\r\n\s]{1,200}(?=\r\n|$)/g)].map((m) => m.index + (m[0].startsWith("\r\n") ? 2 : 0)); + const re = new RegExp(`^content-type:\\s*${type.replace("/", "\\/")}`, "im"); const out = []; for (let i = 0; i < delims.length; i++) { const partStart = body.indexOf("\r\n", delims[i]) + 2; const headersEnd = body.indexOf("\r\n\r\n", partStart); const partEnd = i + 1 < delims.length ? delims[i + 1] : body.length; if (partStart < 2 || headersEnd < 0 || headersEnd > partEnd) continue; - if (/^content-type:\s*text\/html/im.test(body.slice(partStart, headersEnd))) out.push([headersEnd + 4, partEnd]); + if (re.test(body.slice(partStart, headersEnd))) out.push([headersEnd + 4, partEnd]); + } + return out; +} +export const htmlPartRanges = (body) => mimePartRanges(body, "text/html"); + +// Every match of `matcher` in the body (raw, quoted-printable and base64 views), as byte spans +// plus the matched (decoded) text, so reveals can be deduplicated per passage. +function matchSpans(s, matcher) { + const out = []; + for (const view of viewsOf(s)) { + for (const [a, b] of matcher(view.text)) { + const [lo, hi] = view.span ? view.span(a, b) : [view.map(a)[0], view.map(b - 1)[1]]; + out.push({ lo, hi, text: view.text.slice(a, b).replace(/\s+/g, " ").trim() }); + } } return out; } @@ -618,21 +634,30 @@ export function buildMasks(dkim, opts) { // reveals first, hides last: hides always win // REASON: multipart/alternative mail carries the same message twice, as text/plain and as - // text/html. Revealing a sentence in both publishes it twice, the second time wrapped in markup + // text/html. Revealing a passage in both publishes it twice, the second time wrapped in markup // and entities ("can't"), which is noisy and reveals the HTML structure around it for nothing. - // So when a reveal matches outside the HTML part, its copies inside HTML parts stay hidden - // (--reveal-all-parts keeps both). Text that only exists in the HTML part is still revealed there. + // Deduplicated PER MATCH: an HTML match is skipped only when the same matched text also occurs + // in real text/plain content (not MIME headers or attachments, which aren't a readable copy). + // HTML-only passages, including other matches of the same regex, are still revealed. + // --reveal-all-parts keeps every copy. const html = htmlPartRanges(b); - const inHtml = (k) => html.some(([lo, hi]) => k >= lo && k < hi); + const plain = mimePartRanges(b, "text/plain"); + const within = (ranges, lo, hi) => ranges.some(([s0, e0]) => lo >= s0 && hi <= e0); const reveal = (label, matcher) => { - const plain = applyMatches(bodyMask, b, matcher, 1, opts["reveal-all-parts"] || !html.length ? {} : { region: (k) => !inHtml(k) }); - if (plain && html.length && !opts["reveal-all-parts"]) { - if (applyMatches(new Array(b.length), b, matcher, 1, { region: inHtml })) { - warnings.push(`${label}: also in the HTML part; revealed only in the plain-text part (--reveal-all-parts reveals both)`); + const spans = matchSpans(b, matcher); + const plainTexts = new Set(spans.filter((m) => within(plain, m.lo, m.hi)).map((m) => m.text)); + let revealed = 0; + let skipped = 0; + for (const m of spans) { + if (!opts["reveal-all-parts"] && within(html, m.lo, m.hi) && plainTexts.has(m.text)) { + skipped++; + continue; } - return plain; + for (let k = m.lo; k < m.hi; k++) bodyMask[k] = 1; + revealed++; } - return plain || applyMatches(bodyMask, b, matcher, 1); + if (skipped) warnings.push(`${label}: ${skipped} copy(ies) in the HTML part left hidden; the same text is revealed in the plain-text part (--reveal-all-parts reveals both)`); + return revealed; }; for (const t of [].concat(opts.reveal || [])) { if (!reveal(`--reveal "${t}"`, literalMatcher(needleLatin1(t)))) warnings.push(`--reveal "${t}" not found in body`); diff --git a/tests/masked-runs.test.ts b/tests/masked-runs.test.ts index 80c68af..6e0fde0 100644 --- a/tests/masked-runs.test.ts +++ b/tests/masked-runs.test.ts @@ -53,8 +53,34 @@ test("CLI --reveal: text in both the plain and HTML parts is revealed only in th assert.equal(shown(m.bodyMask).match(/We can share/g)?.length, 1, "revealed once"); assert.ok(body.indexOf("We can share") === shown(m.bodyMask).indexOf("We can share") || shown(m.bodyMask).startsWith("█We can share"), "the plain-text copy"); assert.match(shown(m.bodyMask), /Only in html/, "HTML-only text is still revealed"); - assert.ok(m.warnings.some((w: string) => /also in the HTML part/.test(w))); + assert.ok(m.warnings.some((w: string) => /HTML part left hidden/.test(w))); const all = buildMasks(dkim, { "hide-body": true, reveal: ["We can share the lab agreement."], "reveal-all-parts": true }); assert.equal(shown(all.bodyMask).match(/We can share/g)?.length, 2, "--reveal-all-parts keeps both"); }); + +test("CLI --reveal dedupe is per match: a regex still reveals HTML-only passages", async () => { + // @ts-expect-error - plain JS module without types + const { buildMasks } = await import("../skills/redacted-email-proof/scripts/redacted.mjs"); + const body = + "--b1\r\nContent-Type: text/plain\r\n\r\nPublic agreement\r\n" + + "--b1\r\nContent-Type: text/html\r\n\r\n

Public agreement

Private agreement

\r\n--b1--\r\n"; + const dkim = { headers: Buffer.from("from:a@b.example\r\n"), body: Buffer.from(body) }; + const m = buildMasks(dkim, { "hide-body": true, "reveal-regex": ["(Public|Private) agreement"] }); + const shown = [...body].map((c, i) => (m.bodyMask[i] ? c : "\0")).join(""); + assert.equal(shown.match(/Public agreement/g)?.length, 1, "duplicated passage revealed once"); + assert.match(shown, /Private agreement/, "HTML-only match still revealed"); +}); + +test("CLI --reveal: MIME headers/attachments are not a 'plain-text copy' (HTML-only message keeps its reveal)", async () => { + // @ts-expect-error - plain JS module without types + const { buildMasks } = await import("../skills/redacted-email-proof/scripts/redacted.mjs"); + const body = + "--m\r\nContent-Type: text/html\r\n\r\n

See agreement.pdf attached

\r\n" + + '--m\r\nContent-Type: application/pdf; name="agreement.pdf"\r\nContent-Transfer-Encoding: base64\r\n\r\nJVBERi0=\r\n--m--\r\n'; + const dkim = { headers: Buffer.from("from:a@b.example\r\n"), body: Buffer.from(body) }; + const m = buildMasks(dkim, { "hide-body": true, reveal: ["agreement.pdf"] }); + const at = body.indexOf("See agreement.pdf") + 4; + assert.ok(m.bodyMask.slice(at, at + "agreement.pdf".length).every((x: number) => x === 1), "the readable HTML occurrence is revealed"); + assert.ok(!m.warnings.some((w: string) => /HTML part left hidden/.test(w))); +});