Commit Graph
15 Commits
Author SHA1 Message Date
L4XB 30eb570117 fix(hooks): read NUL-ended delimiters, Bash blanks before #, and long bodies
Bash ends a decoded $'...' string at its first NUL, so `cat <<$'EOF\0X'`
ends at the line EOF, but the splitter looked for EOF\0X and swallowed
the commands after the body. A carriage return or a no-break space is
not a blank to Bash, so `echo foo\r# && npm run dev` runs the dev
server, but the splitter read the # as a comment. And spreading a long
substitution's segments into push() threw RangeError, which the hook's
catch turned into an allow. Truncate the decoded part at the NUL, use
Bash's blanks for word starts, and append the segments one at a time.
2026-11-05 13:07:21 +01:00
L4XB 80a26c2ceb fix(hooks): read $$ as the process ID before looking for $'...'
In `echo $$'\'; npm run dev`, Bash reads `$$` as the process-ID parameter
and the quote after it as an ordinary single quote, so it runs
`npm run dev`. The splitter took the second `$` as the start of ANSI-C
quoting, which hid the semicolon, and a here-document delimiter such as
`$$'EOF'` was read as `$EOF`, so the body never ended. Consume the `$$`
pair first in both places.
2026-11-05 10:27:19 +01:00
haelyra 7a0188db61 fix(hooks): honor Bash quote boundaries in dev guard
(cherry picked from commit f4bf43c550)
2026-11-05 10:23:23 +01:00
L4XB 159062e339 fix(hooks): look past a line continuation when deciding whether # starts a comment
Bash removes a backslash-newline before it reads the line, so the character before the pair
decides whether a following # starts a word. `echo \` then `# <<EOF` on the next line is a
comment, and the command after it runs; `echo foo\` then `#bar` stays one word. Count the
backslashes before a blank instead of remembering the last escape, which also took the
continuation for an escaped character.
2026-10-23 12:05:45 +02:00
L4XB 8435c911a5 fix(hooks): match here-document delimiters and comment starts the way bash reads them
A carriage return is part of a bash word and line, so after an LF delimiter a line ending in
\r no longer ends the body early and exposes the body as commands. In an expanded body, a line
ending in an escaping backslash is joined with the next before it is compared, so `EO\` and
`F` end an unquoted <<EOF and the command after it is checked. A # after an escaped blank, as
in `echo foo\ # && npm run dev`, is part of the word, not a comment.
2026-10-23 11:51:47 +02:00
L4XB 19db590a99 fix(hooks): compare ANSI-C delimiter bytes exactly and decode them without spreading
Invalid UTF-8 in a $'...' delimiter became U+FFFD, which a body line could match although Bash compares raw bytes. Such a delimiter now matches no line, so its body runs to the end of the command, as in Bash. The bytes were also spread into one push() call, which threw for a delimiter of 200,000 characters. The hook then failed open. The bytes are now collected as buffers and concatenated once.
2026-10-23 05:02:34 +02:00
L4XB b14ca24446 fix(hooks): decode ANSI-C byte escapes in a here-document delimiter as UTF-8
Bash reads \xHH and \NNN in $'...' as bytes, so <<$'\xc3\xa9' ends at an é line. Each escape became its own character (é), which ended the body at the wrong line. The bytes of the delimiter are now collected and decoded as UTF-8.
2026-10-23 04:42:16 +02:00
L4XB e8759b62e0 fix(hooks): decode the escapes of an ANSI-C quoted here-document delimiter
Bash decodes $'...' quoting, so <<$'E\x4fF' ends at an EOF line. The splitter kept the escape, ended the body at a literal E\x4fF line, and exposed the rest of the body as commands. The delimiter word is now read by readWord(), which decodes $'...' as Bash does, \' included.
2026-10-23 04:20:03 +02:00
L4XB 92b1b2a786 fix(hooks): read an ANSI-C quoted here-document delimiter without its $
Bash reads <<$'EOF' as the delimiter EOF, but the splitter took the $ into the word and waited for a $EOF line, so the body ran on and swallowed the commands after it. A $ before a quote now only starts the quoting.
2026-10-23 03:49:21 +02:00
L4XB ce2b27664f fix(hooks): check the commands that an expanded here-document body runs
Bash expands a here-document body unless part of its delimiter is quoted, and runs the $(...) and backquoted substitutions in it, with quotes as plain text. Leaving the whole body out of the segments hid those commands, so npm --version <<EOF with '$(npm run dev)' in the body was allowed. The commands of these substitutions are now segments of their own. An escaped substitution, or a body whose delimiter is quoted (<<'EOF', <<\EOF), stays data.
2026-10-23 03:13:14 +02:00
L4XB de87e6ec74 fix(hooks): leave here-document bodies out of the shell segments
A body attached to the segment of its command was still searched by the dev-server check. For npm --version <<EOF && cat, the body line npm run dev made the npm segment look like a dev server. A body is data, so it is no longer part of any segment. An empty delimiter (<<'') is a valid opener again, and its body ends at the first empty line.
2026-10-23 02:47:32 +02:00
L4XB d583576552 fix(hooks): read a here-document delimiter as a shell word and keep bodies with their command
The opener pattern read only an identifier, so <<EOF/END stored EOF, <<E"OF" stored E and <<123 was no opener at all. In each case the body was split into segments, or the line after it was swallowed. The delimiter is now read as a shell word with its quotes and backslashes removed, as Bash does. A body that follows an operator at the end of its line (cat <<EOF &&) was split off as a segment of its own. It now goes with the command that opened it.
2026-10-23 02:18:33 +02:00
L4XB 8dedd4ceb3 fix(hooks): read << as a here-document only outside comments and arithmetic
A << in a comment (echo ok # <<EOF) or an identifier shift ($((x << n))) was read as a here-document opener, so the following lines, npm run dev included, were swallowed into its body. A comment now runs to the end of its line and an arithmetic expression is copied whole, so neither opens a here-document nor splits at an operator. A delimiter line ending in \r (CRLF) now ends the body too.
2026-10-23 02:01:04 +02:00
L4XB 2eee66a6c1 fix(hooks): split shell segments at newlines, keeping here-document bodies whole
splitShellSegments() split at &&, ||, ; and & but not at a newline, so a multi-line command such as "cd app\nnpm run dev" was one segment led by cd, and the dev-server block let the dev server through. A newline now ends a segment. The body of a here-document (<<EOF, <<-EOF, <<'EOF') stays in the segment of the command that reads it, so a README written with cat <<EOF that mentions npm run dev is not blocked; a here-string (<<<) or a shift such as $((x << 2)) is not read as one.
2026-10-23 01:45:20 +02:00
zzzhizhi 177dd36e23 fix(hooks): allow tmux-wrapped dev server commands (#321)
* fix(hooks): fix shell splitter redirection/escape bugs, extract shared module

- Fix single & incorrectly splitting redirection operators (&>, >&, 2>&1)
- Fix escaped quotes (\", \') not being handled inside quoted strings
- Extract splitShellSegments into shared scripts/lib/shell-split.js
  to eliminate duplication between hooks.json, before-shell-execution.js,
  and pre-bash-dev-server-block.js
- Add comprehensive tests for shell splitting edge cases

* fix(hooks): handle backslash escapes outside quotes in shell splitter

Escaped operators like \&& and \; outside quotes were still being
treated as separators. Add escape handling for unquoted context.
2026-03-07 14:47:49 -08:00