Greptile Summary

This PR adds a new stripImessageLengthPrefixedUtf8Text helper that removes a protobuf-style varint length header from inbound iMessage text and reply_to_text fields when the header + payload exactly exhausts the buffer, and wires it into parseIMessageNotification after type validation. The conservative exact-match guard makes false positives on normal text practically impossible.

Confidence Score: 5/5

Safe to merge — logic is correct and conservative; the only finding is a misleading test description with missing two-byte varint coverage.

All findings are P2. The implementation correctly handles the stated goal, the exact-length guard prevents false positives, and Unicode edge cases are safe. The test labeled "multi-byte varint" actually uses a single-byte varint (0x7F), leaving the two-byte decoding path unverified, but the production code logic is sound.

extensions/imessage/src/monitor/strip-imsg-length-prefixed-text.test.ts — misleading test name and missing two-byte varint case.

This is a comment left during a code review.
Path: extensions/imessage/src/monitor/strip-imsg-length-prefixed-text.test.ts
Line: 10-15

Comment:
**Misleading test name — single-byte varint, not multi-byte**

`0x7F` has bit 7 clear, so it is the terminal byte of a **one-byte** varint with value 127, not a multi-byte varint. A genuinely two-byte varint (e.g. `0x80 0x01` for value 128) is not exercised here, leaving the multi-byte decoding path untested. Renaming the case and adding a companion case with a real two-byte prefix would lock in that path.

```suggestion
  it("removes a 127-byte payload behind a single-byte varint length", () => {
    const inner = "a".repeat(127);
    const buf = Buffer.allocUnsafe(1 + inner.length);
    buf.writeUInt8(0x7f, 0);
    buf.write(inner, 1, "utf8");
    expect(stripImessageLengthPrefixedUtf8Text(buf.toString("utf8"))).toBe(inner);
  });

  it("removes a 128-byte payload behind a two-byte varint length", () => {
    const inner = "a".repeat(128);
    // Varint for 128: 0x80 0x01
    const buf = Buffer.allocUnsafe(2 + inner.length);
    buf.writeUInt8(0x80, 0);
    buf.writeUInt8(0x01, 1);
    buf.write(inner, 2, "utf8");
    expect(stripImessageLengthPrefixedUtf8Text(buf.toString("utf8"))).toBe(inner);
  });
```

How can I resolve this? If you propose a fix, please make it concise.

_{Reviews (1): Last reviewed commit: "fix(imessage): strip length-prefixed UTF..." | Re-trigger Greptile}

Review feedback addressed (latest: 61f313ccd1)

chatgpt-codex-connector (P1) — false positive strip when one ASCII byte matches framing

• Added a guard: if the length is encoded as a single-byte varint and that byte is in the ASCII printable range 0x20–0x7e, we do not strip (return original text). That blocks the reported case where the first character (e.g. A / 0x41) could be misread as length 65 for a 66-byte UTF-8 buffer.
• Multibyte varints (continuation bytes) are unchanged: first varint byte has bit 7 set, so they never fall in the printable ASCII range and still strip when the payload consumes the full remainder.
• Control / non-printable single-byte lengths (e.g. 0x05, 0x0b, 0x7f) still strip as before.

greptile-apps — test naming and two-byte varint coverage

• Renamed the 127-byte case to state it uses a single-byte varint (0x7f).
• Added a two-byte varint case for length 128 (0x80 0x01) using raw Buffer input via the new tryStripImessageLengthPrefixedUtf8Buffer helper. Raw bytes like 0x80 0x01 are not round-trippable through JS strings plus Buffer.from(text, "utf8"), so the buffer-level API documents that limitation and keeps the multibyte decode path covered in tests.
• Added a regression test that a string starting with A + 65× b (66 UTF-8 bytes) is left unchanged.

Changelog

• Unreleased entry updated to mention the ASCII-printable skip.

pnpm test:extension imessage and pnpm check are green on this branch.

🔒 Aisle Security Analysis

We found 1 potential security issue(s) in this PR:

const stripped = tryStripImessageLengthPrefixedUtf8Buffer(Buffer.from(text, "utf8"));
...
const inner = utf8Decoder.decode(stripped);

const MAX_STRIP_BYTES = 64 * 1024; // choose an appropriate bound

export function stripImessageLengthPrefixedUtf8Text(text: string): string {
  if (!text) return text;

  ​// Prevent large allocations/CPU on attacker-controlled input
  if (Buffer.byteLength(text, "utf8") > MAX_STRIP_BYTES) {
    return text;
  }

  try {
    const buf = Buffer.from(text, "utf8");
    const stripped = tryStripImessageLengthPrefixedUtf8Buffer(buf);
    if (!stripped) return text;

    const inner = utf8Decoder.decode(stripped);
    return inner.length > 0 ? inner : text;
  } catch {
    return text; // fail open; preserve original text
  }
}

Analyzed PR: #64000 at commit 4ba523d

_{Last updated on: 2026-04-10T08:36:08Z}

Landed on main.

• Landed source commit: 4ba523d
• Merge commit: 782b562

Thanks @neeravmakwana.