Match heredoc terminators exactly, with tab-stripping only for <<-

Trim-based closing accepted a space-indented marker for plain << and kept a stray carriage return in CRLF markers, so the splitter and the approval display disagreed with the shell about where a heredoc ends. Compare exact lines instead.

Author: TheGreatAxios

src/permission/command.test.ts

@@ -151,3 +151,45 @@ describe("splitChainedCommand redirect and background fragments", () => {
     expect(splitChainedCommand(prose)).toEqual([prose]);
   });
 });
+
+describe("splitChainedCommand heredoc boundaries", () => {
+  // A marker glued to `<<` is still an opener, and separators trailing the
+  // opener line do not split while the heredoc body is pending.
+  test("keeps separators on the opener line inside a glued-marker heredoc", () => {
+    const command = "cat <<B && echo done\nbody\nB";
+    expect(splitChainedCommand(command)).toEqual([command]);
+    const semicolon = "cat <<EOF; echo done\nbody\nEOF";
+    expect(splitChainedCommand(semicolon)).toEqual([semicolon]);
+  });
+
+  test("opens and closes a heredoc across CRLF line endings", () => {
+    const command = "cat <<EOF\r\nbody\r\nEOF";
+    expect(splitChainedCommand(command)).toEqual([command]);
+    expect(
+      splitChainedCommand("cat <<EOF\r\nbody\r\nEOF\r\n&& echo done"),
+    ).toEqual(["cat <<EOF\r\nbody\r\nEOF", "echo done"]);
+  });
+
+  // Only `<<-` strips leading tabs from the closing line; a space-indented
+  // close never terminates a plain `<<` heredoc.
+  test("closes <<- on a tab-indented marker but not << on spaces", () => {
+    expect(
+      splitChainedCommand("cat <<-EOF\nbody\n\tEOF\n&& echo evil"),
+    ).toEqual(["cat <<-EOF\nbody\n\tEOF", "echo evil"]);
+    const spaces = "cat <<EOF\nbody\n  EOF\n&& echo evil";
+    expect(splitChainedCommand(spaces)).toEqual([spaces]);
+  });
+
+  test("an unterminated heredoc swallows a later chain separator", () => {
+    const command = "cat <<EOF\nbody\n&& echo evil";
+    expect(splitChainedCommand(command)).toEqual([command]);
+  });
+
+  // Single-slot heredoc state: a second `<<` inside the body is payload, so
+  // the outer marker still closes and the following chain still splits.
+  test("treats a second << inside the body as payload, not a nested opener", () => {
+    expect(
+      splitChainedCommand("cat <<OUTER\nfoo <<INNER\nOUTER\n&& echo done"),
+    ).toEqual(["cat <<OUTER\nfoo <<INNER\nOUTER", "echo done"]);
+  });
+});

src/permission/command.ts

@@ -1,6 +1,9 @@
 import type { ApprovalScope } from "./types.js";
 import { escapeGlobLiteral } from "./matcher.js";
-import { parseHeredocOpener } from "../shell/command-segments.js";
+import {
+  isHeredocTerminator,
+  parseHeredocOpener,
+} from "../shell/command-segments.js";
 
 export { splitChainedCommand } from "../shell/command-segments.js";
 
@@ -29,6 +32,7 @@ export function stripCommentLines(command: string): string {
   let commentState: "unknown" | "yes" | "no" = "unknown";
   let quote: '"' | "'" | "`" | null = null;
   let heredocMarker: string | null = null;
+  let heredocStripTabs = false;
 
   const flushLine = (): void => {
     if (commentState !== "yes") out += line;
@@ -44,7 +48,10 @@ export function stripCommentLines(command: string): string {
       if (ch === "\n") {
         const lines = line.split("\n");
         const lastLine = lines[lines.length - 2] ?? "";
-        if (lastLine.trim() === heredocMarker) heredocMarker = null;
+        if (isHeredocTerminator(lastLine, heredocMarker, heredocStripTabs)) {
+          heredocMarker = null;
+          heredocStripTabs = false;
+        }
         out += line;
         line = "";
       }
@@ -91,6 +98,7 @@ export function stripCommentLines(command: string): string {
         line += command.slice(i, opener.lineEnd);
         i = opener.lineEnd - 1;
         heredocMarker = opener.marker;
+        heredocStripTabs = opener.stripTabs;
         continue;
       }
     }

src/shell/command-segments.ts

@@ -13,6 +13,7 @@ export function splitChainedCommand(command: string): string[] {
   let current = "";
   let quote: '"' | "'" | "`" | null = null;
   let heredocMarker: string | null = null;
+  let heredocStripTabs = false;
   let parenDepth = 0;
 
   const push = (): void => {
@@ -31,14 +32,16 @@ export function splitChainedCommand(command: string): string[] {
     const ch = command[i] as string;
 
     // Inside a heredoc body: scan for the terminating marker on its own line.
+    // A second `<<` down here is payload, never a nested opener.
     if (heredocMarker !== null) {
       current += ch;
       if (ch === "\n") {
         // Check whether the line just completed is the marker.
         const lines = current.split("\n");
         const lastLine = lines[lines.length - 2] ?? "";
-        if (lastLine.trim() === heredocMarker) {
+        if (isHeredocTerminator(lastLine, heredocMarker, heredocStripTabs)) {
           heredocMarker = null;
+          heredocStripTabs = false;
         }
       }
       continue;
@@ -75,6 +78,7 @@ export function splitChainedCommand(command: string): string[] {
         current += command.slice(i, opener.lineEnd);
         i = opener.lineEnd - 1;
         heredocMarker = opener.marker;
+        heredocStripTabs = opener.stripTabs;
         continue;
       }
     }
@@ -142,15 +146,16 @@ export function splitChainedCommand(command: string): string[] {
 }
 
 // Parses a heredoc opener (`<<` or `<<-`) starting at `command[i]` (which must
-// be the first "<"). Returns the terminating marker text and the exclusive end
-// index of the line that opened the heredoc, so the caller can copy the
-// opening line verbatim and resume scanning the heredoc body from there.
+// be the first "<"). Returns the terminating marker text, the exclusive end
+// index of the line that opened the heredoc, and whether the opener was `<<-`
+// (which strips leading tabs from the closing line) — so the caller can copy
+// the opening line verbatim and resume scanning the heredoc body from there.
 // Shared by splitChainedCommand and stripCommentLines so both stay in sync on
 // what counts as heredoc syntax.
 export function parseHeredocOpener(
   command: string,
   i: number,
-): { marker: string; lineEnd: number } | null {
+): { marker: string; lineEnd: number; stripTabs: boolean } | null {
   if (command[i] !== "<" || command[i + 1] !== "<") return null;
   // `<<<` is a here-string, not a heredoc: its word is an inline argument,
   // so there is no marker line to wait for.
@@ -162,7 +167,8 @@ export function parseHeredocOpener(
   // command as body.
   if (command[i - 1] === "<") return null;
   let j = i + 2;
-  if (command[j] === "-") j++; // <<- strips leading tabs
+  const stripTabs = command[j] === "-";
+  if (stripTabs) j++; // <<- strips leading tabs
   // Skip whitespace between << and the marker word.
   while (j < command.length && (command[j] === " " || command[j] === "\t")) j++;
   // The marker may be quoted ('EOF', "EOF", or bare EOF).
@@ -184,9 +190,27 @@ export function parseHeredocOpener(
     marker += command[j++];
   }
   if (markerQuote !== null && command[j] === markerQuote) j++;
+  // A CRLF opener line leaves a trailing \r on a bare marker word; the
+  // terminator line carries the same \r, so drop it here and compare
+  // CR-stripped lines at close time.
+  if (marker.endsWith("\r")) marker = marker.slice(0, -1);
   // Advance j to the end of the line that opened the heredoc.
   while (j < command.length && command[j] !== "\n") j++;
-  return { marker, lineEnd: j };
+  return { marker, lineEnd: j, stripTabs };
+}
+
+// Whether a completed body line closes a heredoc: an exact match against the
+// marker, ignoring one trailing CR from CRLF input and leading tabs only when
+// the opener was `<<-`. A space-indented close never terminates a plain `<<`
+// heredoc — it stays body, exactly like a real shell.
+export function isHeredocTerminator(
+  line: string,
+  marker: string,
+  stripTabs: boolean,
+): boolean {
+  const noCR = line.endsWith("\r") ? line.slice(0, -1) : line;
+  const candidate = stripTabs ? noCR.replace(/^\t+/, "") : noCR;
+  return candidate === marker;
 }
 
 // Whether `text` ends (ignoring trailing whitespace) in a redirect operator

src/tui/command-display.test.ts

@@ -17,6 +17,9 @@ test("display segments exactly match authorization segments", () => {
     `echo "a && b" | cat`,
     "cat > /tmp/out.md << 'EOF'\nline one; still body && more\nEOF",
     "cat << 'EOF'\nline one; still body && more\nEOF\necho after",
+    "cat <<-EOF\nbody\n\tEOF\n&& echo evil",
+    "cat <<EOF\nbody\n  EOF\n&& echo evil",
+    "cat <<EOF\r\nbody\r\nEOF\r\n&& echo done",
     "cmd1 && \\\ncmd2",
     "(cd packages/shared && bunx tsc --noEmit 2>&1 | tail -3)",
     "echo start && (cd apps/web && bun test) && echo done",
@@ -102,6 +105,32 @@ test("heredoc body lines are never flagged as comments", () => {
   ]);
 });
 
+test("a tab-indented line closes a <<- heredoc; spaces never close <<", () => {
+  expect(verbatimCommandLines("cat <<-EOF\n\tbody\n\tEOF")).toEqual([
+    { text: "cat <<-EOF", isComment: false },
+    { text: "\tbody", isComment: false },
+    { text: "\tEOF", isComment: false },
+  ]);
+  // The space-indented marker stays body, so a later # line is still payload.
+  expect(verbatimCommandLines("cat <<EOF\n  EOF\n# payload\nEOF")).toEqual([
+    { text: "cat <<EOF", isComment: false },
+    { text: "  EOF", isComment: false },
+    { text: "# payload", isComment: false },
+    { text: "EOF", isComment: false },
+  ]);
+});
+
+test("a CRLF heredoc closes and frees the following chain", () => {
+  expect(
+    verbatimCommandLines("cat <<EOF\r\nbody\r\nEOF\r\n&& echo done"),
+  ).toEqual([
+    { text: "cat <<EOF", isComment: false },
+    { text: "body", isComment: false },
+    { text: "EOF", isComment: false },
+    { text: "&& echo done", isComment: false },
+  ]);
+});
+
 test("bare carriage returns render as a visible marker", () => {
   expect(verbatimCommandLines("echo safe\rrm -rf /")).toEqual([
     { text: "echo safe↵rm -rf /", isComment: false },
@@ -128,6 +157,15 @@ test("collapseSegmentPayloads collapses a heredoc body to a placeholder with a l
   ]);
 });
 
+test("collapseSegmentPayloads closes a <<- body on its tab-indented marker", () => {
+  const segment = "cat <<-EOF\n\tbody\n\tEOF\n&& echo done";
+  const { display, payloads } = collapseSegmentPayloads(segment);
+  expect(display).toBe("cat <<-EOF <heredoc, 1 line>&& echo done");
+  expect(payloads).toEqual([
+    { placeholder: "<heredoc, 1 line>", lines: ["\tbody"] },
+  ]);
+});
+
 test("collapseSegmentPayloads collapses a multi-line -m message to <message, N lines>", () => {
   const segment = 'git commit -m "line one\nline two\nline three"';
   const { display, payloads } = collapseSegmentPayloads(segment);