Linux 脚本报 bad interpreter：用 Python 定位并修复 CRLF 与 BOM

python3 --version
mkdir script-bytes-demo
cd script-bytes-demo
python3 - <<'PY_DATA'
import codecs
from pathlib import Path

script = b"#!/bin/sh\nprintf 'job ok\\n'\n"
Path("good.sh").write_bytes(script)
Path("bad-crlf.sh").write_bytes(script.replace(b"\n", b"\r\n"))
Path("bad-bom.sh").write_bytes(codecs.BOM_UTF8 + script)
Path("bare-cr.sh").write_bytes(b"#!/bin/sh\rprintf 'stop'\r")
for name in ("good.sh", "bad-crlf.sh", "bad-bom.sh"):
    Path(name).chmod(0o700)
PY_DATA

python3 - <<'PY_DIAG'
from pathlib import Path
import subprocess

for name in ("good.sh", "bad-crlf.sh", "bad-bom.sh"):
    raw = Path(name).read_bytes()
    print(name, "first_line=", repr(raw.split(b"\n", 1)[0]), flush=True)
    try:
        result = subprocess.run(["./" + name], capture_output=True, check=False)
    except OSError as exc:
        print("exec failed:", exc.errno, exc.strerror)
    else:
        print("exit=", result.returncode, "stdout=", repr(result.stdout))
PY_DIAG

good.sh first_line= b'#!/bin/sh'
exit= 0 stdout= b'job ok\n'
bad-crlf.sh first_line= b'#!/bin/sh\r'
exec failed: 2 No such file or directory
bad-bom.sh first_line= b'\xef\xbb\xbf#!/bin/sh'
exec failed: 8 Exec format error

"""Check UTF-8 script line endings, or write a new LF copy. Python 3.9+."""
import argparse
import codecs
from pathlib import Path
import sys

MAX_BYTES = 1024 * 1024


def inspect_script(path):
    if not path.is_file():
        raise ValueError("input must be a regular file")
    with path.open("rb") as source:
        raw = source.read(MAX_BYTES + 1)
    if len(raw) > MAX_BYTES:
        raise ValueError("input exceeds 1 MiB")
    bom = raw.startswith(codecs.BOM_UTF8)
    body = raw[len(codecs.BOM_UTF8):] if bom else raw
    body.decode("utf-8", errors="strict")
    if b"\x00" in body:
        raise ValueError("NUL byte: expected a UTF-8 text script")
    if not body.startswith(b"#!"):
        raise ValueError("expected #! at the start after an optional UTF-8 BOM")
    crlf = body.count(b"\r\n")
    bare_cr = body.count(b"\r") - crlf
    return body, bom, crlf, bare_cr


def main():
    parser = argparse.ArgumentParser(description=__doc__, allow_abbrev=False)
    parser.add_argument("source", type=Path)
    parser.add_argument("--output", type=Path,
                        help="create a new LF copy; never overwrite a path")
    args = parser.parse_args()
    try:
        body, bom, crlf, bare_cr = inspect_script(args.source)
        print(f"bom={int(bom)} crlf={crlf} bare_cr={bare_cr}")
        if args.output is None:
            return 1 if bom or crlf or bare_cr else 0
        if bare_cr:
            raise ValueError("bare CR found; inspect the source manually")
        cleaned = body.replace(b"\r\n", b"\n")
        with args.output.open("xb") as target:
            target.write(cleaned)
        print(f"WROTE: {args.output}")
        return 0
    except (OSError, ValueError, UnicodeError) as exc:
        print(f"ERROR: {exc}", file=sys.stderr)
        return 1


if __name__ == "__main__":
    raise SystemExit(main())

python3 normalize_script.py --help
if python3 normalize_script.py bad-crlf.sh; then
  printf 'Already clean\n'
else
  printf 'Check reported a problem; inspect before repairing\n'
fi
python3 normalize_script.py bad-crlf.sh --output repaired.sh
python3 normalize_script.py repaired.sh
/bin/sh -n repaired.sh
chmod u+x repaired.sh
./repaired.sh

python3 normalize_script.py bad-bom.sh --output repaired-bom.sh
python3 normalize_script.py repaired-bom.sh
/bin/sh -n repaired-bom.sh
/bin/sh repaired-bom.sh

python3 - <<'PY_CHECK'
import codecs
from pathlib import Path
import subprocess
import sys


def run(*arguments):
    return subprocess.run(
        [sys.executable, "normalize_script.py", *arguments],
        capture_output=True, text=True, check=False,
    )


assert run("--help").returncode == 0
assert run("good.sh").returncode == 0
for name in ("bad-crlf.sh", "bad-bom.sh", "bare-cr.sh"):
    result = run(name)
    assert result.returncode == 1, result

for source, output in (("bad-crlf.sh", "fixed-crlf.sh"),
                       ("bad-bom.sh", "fixed-bom.sh")):
    before = Path(source).read_bytes()
    result = run(source, "--output", output)
    assert result.returncode == 0, result
    assert Path(source).read_bytes() == before
    cleaned = Path(output).read_bytes()
    assert cleaned == Path("good.sh").read_bytes()
    assert not cleaned.startswith(codecs.BOM_UTF8) and b"\r" not in cleaned
    result = run(source, "--output", output)
    assert result.returncode == 1, result
    assert Path(output).read_bytes() == cleaned
    result = subprocess.run(["/bin/sh", output], capture_output=True, check=False)
    assert result.returncode == 0 and result.stdout == b"job ok\n", result

assert run("bare-cr.sh", "--output", "refused.sh").returncode == 1
assert not Path("refused.sh").exists()
assert run("missing.sh").returncode == 1
assert run(".").returncode == 1
assert run("good.sh", "--unknown").returncode == 2
print("OK: detection, repair, unchanged sources, no overwrite, errors")
PY_CHECK

OK: detection, repair, unchanged sources, no overwrite, errors

*.sh text eol=lf
*.py text eol=lf

git check-attr text eol -- scripts/job.sh