py-posix-shell 0.4.2__tar.gz → 0.4.3__tar.gz

{py_posix_shell-0.4.2 → py_posix_shell-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-posix-shell
-Version: 0.4.2
+Version: 0.4.3
 Summary: A cross-platform POSIX-style shell written in Python.
 Author: GGN_2015
 License-Expression: MIT
@@ -58,7 +58,7 @@ scripts:
   `sort`, `uniq`, `wc`, `cut`, `head`, `tail`, `chmod`, `chown`, `chgrp`,
   `echo`, `date`, `sleep`, `printf`, `basename`, `dirname`, `whoami`, `yes`,
   `find`, `xargs`, `locate`, `updatedb`, `diff`, `cmp`, `diff3`, `sdiff`,
-  `grep`, `egrep`, `fgrep`, `sed`, `awk`, `gawk`, and `tar`
+  `grep`, `egrep`, `fgrep`, `sed`, `awk`, `gawk`, `base64`, `tr`, and `tar`
 
 The implementation intentionally remains dependency-free at runtime. It aims for
 useful POSIX behavior first, then progressively tighter compatibility with

{py_posix_shell-0.4.2 → py_posix_shell-0.4.3}/README.md

@@ -35,7 +35,7 @@ scripts:
   `sort`, `uniq`, `wc`, `cut`, `head`, `tail`, `chmod`, `chown`, `chgrp`,
   `echo`, `date`, `sleep`, `printf`, `basename`, `dirname`, `whoami`, `yes`,
   `find`, `xargs`, `locate`, `updatedb`, `diff`, `cmp`, `diff3`, `sdiff`,
-  `grep`, `egrep`, `fgrep`, `sed`, `awk`, `gawk`, and `tar`
+  `grep`, `egrep`, `fgrep`, `sed`, `awk`, `gawk`, `base64`, `tr`, and `tar`
 
 The implementation intentionally remains dependency-free at runtime. It aims for
 useful POSIX behavior first, then progressively tighter compatibility with

{py_posix_shell-0.4.2 → py_posix_shell-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "py-posix-shell"
-version = "0.4.2"
+version = "0.4.3"
 description = "A cross-platform POSIX-style shell written in Python."
 readme = "README.md"
 requires-python = ">=3.10"

{py_posix_shell-0.4.2 → py_posix_shell-0.4.3}/src/py_posix_shell/__init__.py

@@ -1,3 +1,3 @@
 """A cross-platform POSIX-style shell."""
 
-__version__ = "0.4.2"
+__version__ = "0.4.3"

{py_posix_shell-0.4.2 → py_posix_shell-0.4.3}/src/py_posix_shell/parser.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass, field
 from typing import TypeAlias
 
 from .errors import ParseError
-from .lexer import Operator, Token, Word, is_name, lex
+from .lexer import Operator, Part, Token, Word, is_name, lex
 
 
 @dataclass(frozen=True)
@@ -293,6 +293,9 @@ class Parser:
 
         while not self._at_end() and not self._at_stop(stop_words, stop_ops):
             token = self._peek()
+            if isinstance(token, Word) and self._is_array_append_assignment(token) and not seen_command_word:
+                assignments.append(self._parse_array_append_assignment())
+                continue
             if isinstance(token, Operator):
                 redir = parse_redirection_operator(token.value)
                 if redir is None:
@@ -315,6 +318,22 @@ class Parser:
             raise ParseError(f"expected command, got {self._describe(token)}")
         return SimpleCommand(tuple(assignments), tuple(words), tuple(redirections))
 
+    def _is_array_append_assignment(self, token: Word) -> bool:
+        return (
+            token.text.endswith("+=")
+            and is_name(token.text[:-2])
+            and self._peek_operator(1) == "("
+        )
+
+    def _parse_array_append_assignment(self) -> tuple[str, Word]:
+        name = self._consume_word().text[:-2]
+        self._expect_operator("(")
+        values: list[str] = []
+        while not self._at_end() and self._peek_operator() != ")":
+            values.append(self._consume_word().text)
+        self._expect_operator(")")
+        return name, Word((Part(" ".join(values)),))
+
     def _parse_redirections(self) -> tuple[Redirection, ...]:
         redirections: list[Redirection] = []
         while not self._at_end():

{py_posix_shell-0.4.2 → py_posix_shell-0.4.3}/src/py_posix_shell/posix_utils.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import ast
+import base64
+import binascii
 import datetime as _datetime
 import difflib
 import fnmatch
@@ -51,6 +53,97 @@ def utility_cat(shell, argv: list[str], stdin: TextIO, stdout: TextIO, stderr: T
     return status
 
 
+def utility_base64(shell, argv: list[str], stdin: TextIO, stdout: TextIO, stderr: TextIO) -> int:
+    decode = False
+    paths: list[str] = []
+    i = 1
+    while i < len(argv):
+        arg = argv[i]
+        if arg == "--":
+            paths.extend(argv[i + 1 :])
+            break
+        if arg in {"-d", "-D", "--decode"}:
+            decode = True
+        elif arg in {"-w", "--wrap"}:
+            i += 1
+            if i >= len(argv):
+                stderr.write("base64: option requires an argument -- w\n")
+                return 2
+        elif arg.startswith("-w") and len(arg) > 2:
+            pass
+        elif arg.startswith("-") and arg != "-":
+            for flag in arg[1:]:
+                if flag in {"d", "D"}:
+                    decode = True
+                else:
+                    stderr.write(f"base64: invalid option -- {flag}\n")
+                    return 2
+        else:
+            paths.append(arg)
+        i += 1
+
+    try:
+        data = b"".join(read_binary_inputs(paths or ["-"], stdin))
+        if decode:
+            decoded = base64.b64decode(b"".join(data.split()), validate=False)
+            write_binary_output(stdout, decoded)
+        else:
+            encoded = base64.encodebytes(data)
+            write_binary_output(stdout, encoded)
+    except (binascii.Error, ValueError) as exc:
+        stderr.write(f"base64: invalid input: {exc}\n")
+        return 1
+    except OSError as exc:
+        stderr.write(f"base64: {exc.strerror or exc}\n")
+        return 1
+    return 0
+
+
+def utility_tr(shell, argv: list[str], stdin: TextIO, stdout: TextIO, stderr: TextIO) -> int:
+    delete = False
+    squeeze = False
+    args: list[str] = []
+    for arg in argv[1:]:
+        if arg == "--":
+            continue
+        if arg.startswith("-") and arg != "-":
+            for flag in arg[1:]:
+                if flag == "d":
+                    delete = True
+                elif flag == "s":
+                    squeeze = True
+                else:
+                    stderr.write(f"tr: invalid option -- {flag}\n")
+                    return 2
+        else:
+            args.append(arg)
+    if delete:
+        if not args:
+            stderr.write("tr: missing operand\n")
+            return 2
+        delete_chars = set(expand_tr_set(args[0]))
+        squeeze_chars = set(expand_tr_set(args[1])) if squeeze and len(args) > 1 else delete_chars
+        result = "".join(char for char in stdin.read() if char not in delete_chars)
+        stdout.write(squeeze_repeated_chars(result, squeeze_chars) if squeeze else result)
+        return 0
+    if len(args) < 2:
+        stderr.write("tr: missing operand after set1\n")
+        return 2
+    source = expand_tr_set(args[0])
+    target = expand_tr_set(args[1])
+    if not target:
+        stderr.write("tr: set2 must not be empty\n")
+        return 2
+    translation: dict[int, str] = {}
+    for index, char in enumerate(source):
+        translation[ord(char)] = target[index] if index < len(target) else target[-1]
+    result = stdin.read().translate(translation)
+    if squeeze:
+        result = squeeze_repeated_chars(result, set(target))
+    stdout.write(result)
+    return 0
+
+
 def utility_ls(shell, argv: list[str], stdin: TextIO, stdout: TextIO, stderr: TextIO) -> int:
     show_all = False
     almost_all = False
@@ -389,11 +482,15 @@ def utility_wc(shell, argv: list[str], stdin: TextIO, stdout: TextIO, stderr: Te
 
     rows: list[tuple[int, int, int, str | None]] = []
     status = 0
-    for path, text in read_text_inputs(paths or ["-"], stdin, stderr, "wc"):
-        if text is None:
+    for path in paths or ["-"]:
+        try:
+            data = next(iter(read_binary_inputs([path], stdin)))
+        except OSError as exc:
+            stderr.write(f"wc: {path}: {exc.strerror or exc}\n")
             status = 1
             continue
-        rows.append((text.count("\n"), len(text.split()), len(text.encode("utf-8")), None if path == "-" else path))
+        text = data.decode("utf-8", errors="replace")
+        rows.append((data.count(b"\n"), len(text.split()), len(data), None if path == "-" else path))
     for lines, words, bytes_count, name in rows:
         values: list[str] = []
         if count_lines:
@@ -1518,12 +1615,13 @@ def display_name(entry: Path, base: Path) -> str:
 
 def format_long_listing(path: Path, name: str) -> str:
     try:
-        info = path.stat()
+        info = path.lstat()
     except OSError:
-        return f"?????????? 0 {name}"
+        return f"?????????? 0 unknown unknown 0 Jan 01 00:00 {name}"
     mode = stat.filemode(info.st_mode)
     mtime = _datetime.datetime.fromtimestamp(info.st_mtime).strftime("%b %d %H:%M")
-    return f"{mode} 1 {info.st_size:>8} {mtime} {name}"
+    owner, group = owner_group_names(info)
+    return f"{mode} {getattr(info, 'st_nlink', 1):>2} {owner:<8} {group:<8} {info.st_size:>8} {mtime} {name}"
 
 
 def parse_line_count_args(command: str, argv: list[str], stderr: TextIO, *, default: int) -> tuple[int, list[str], int]:
@@ -1616,6 +1714,127 @@ def parse_csv_line(line: str) -> list[str]:
     return result
 
 
+def read_binary_inputs(paths: Iterable[str], stdin: TextIO) -> Iterable[bytes]:
+    for path in paths:
+        if path == "-":
+            buffer = getattr(stdin, "buffer", None)
+            if buffer is not None:
+                yield buffer.read()
+            else:
+                yield stdin.read().encode("utf-8")
+            continue
+        yield Path(path).read_bytes()
+
+
+def write_binary_output(stdout: TextIO, data: bytes) -> None:
+    buffer = getattr(stdout, "buffer", None)
+    if buffer is not None:
+        buffer.write(data)
+        buffer.flush()
+    else:
+        stdout.write(data.decode("latin-1"))
+
+
+def expand_tr_set(spec: str) -> str:
+    result: list[str] = []
+    index = 0
+    while index < len(spec):
+        first, index = read_tr_unit(spec, index)
+        if index < len(spec) - 1 and spec[index] == "-" and len(first) == 1:
+            second, next_index = read_tr_unit(spec, index + 1)
+            if len(second) == 1:
+                start = ord(first)
+                end = ord(second)
+                step = 1 if start <= end else -1
+                result.extend(chr(value) for value in range(start, end + step, step))
+                index = next_index
+                continue
+        result.extend(first)
+    return "".join(result)
+
+
+def read_tr_unit(spec: str, index: int) -> tuple[str, int]:
+    if spec.startswith("[:", index):
+        end = spec.find(":]", index + 2)
+        if end != -1:
+            name = spec[index + 2 : end]
+            return tr_character_class(name), end + 2
+    char = spec[index]
+    if char != "\\":
+        return char, index + 1
+    if index + 1 >= len(spec):
+        return "\\", index + 1
+    marker = spec[index + 1]
+    escapes = {
+        "a": "\a",
+        "b": "\b",
+        "f": "\f",
+        "n": "\n",
+        "r": "\r",
+        "t": "\t",
+        "v": "\v",
+        "\\": "\\",
+    }
+    if marker in escapes:
+        return escapes[marker], index + 2
+    if marker in "01234567":
+        end = index + 1
+        while end < len(spec) and end < index + 4 and spec[end] in "01234567":
+            end += 1
+        return chr(int(spec[index + 1 : end], 8)), end
+    return marker, index + 2
+
+
+def tr_character_class(name: str) -> str:
+    classes = {
+        "alnum": "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+        "alpha": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+        "blank": " \t",
+        "digit": "0123456789",
+        "lower": "abcdefghijklmnopqrstuvwxyz",
+        "space": " \t\r\n\v\f",
+        "upper": "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+        "xdigit": "0123456789ABCDEFabcdef",
+    }
+    return classes.get(name, "")
+
+
+def squeeze_repeated_chars(text: str, chars: set[str]) -> str:
+    if not text or not chars:
+        return text
+    result: list[str] = []
+    previous = ""
+    for char in text:
+        if char == previous and char in chars:
+            continue
+        result.append(char)
+        previous = char
+    return "".join(result)
+
+
+def owner_group_names(info: os.stat_result) -> tuple[str, str]:
+    owner = str(getattr(info, "st_uid", "user"))
+    group = str(getattr(info, "st_gid", "group"))
+    if pwd is not None:
+        try:
+            owner = pwd.getpwuid(info.st_uid).pw_name
+        except (KeyError, AttributeError):
+            pass
+    else:
+        try:
+            owner = getpass.getuser()
+        except OSError:
+            owner = "user"
+    if grp is not None:
+        try:
+            group = grp.getgrgid(info.st_gid).gr_name
+        except (KeyError, AttributeError):
+            pass
+    elif not group or group.isdigit():
+        group = owner
+    return owner.replace(" ", "_"), group.replace(" ", "_")
+
+
 def split_owner_group(spec: str) -> tuple[str | None, str | None]:
     separator = ":" if ":" in spec else "." if "." in spec else ""
     if not separator:
@@ -2344,6 +2563,7 @@ def sys_argv0() -> str:
 INTERNAL_UTILITIES: dict[str, Utility] = {
     "awk": utility_gawk,
     "basename": utility_basename,
+    "base64": utility_base64,
     "cat": utility_cat,
     "chmod": utility_chmod,
     "chgrp": utility_chgrp,
@@ -2382,6 +2602,7 @@ INTERNAL_UTILITIES: dict[str, Utility] = {
     "tail": utility_tail,
     "tar": utility_tar,
     "touch": utility_touch,
+    "tr": utility_tr,
     "uname": utility_uname,
     "uniq": utility_uniq,
     "unlink": utility_unlink,

{py_posix_shell-0.4.2 → py_posix_shell-0.4.3}/src/py_posix_shell/shell.py

@@ -17,7 +17,7 @@ from typing import Iterator, TextIO
 
 from .builtins import BUILTINS, SPECIAL_BUILTINS
 from .errors import ExpansionError, LexerError, ParseError, ShellBreak, ShellContinue, ShellExit, ShellReturn
-from .expansion import expand_assignment, expand_here_document, expand_redirection, expand_word
+from .expansion import chars_to_text, expand_assignment, expand_here_document, expand_redirection, expand_text, expand_word
 from .lexer import Operator, Word, lex
 from .parser import (
     AndOrList,
@@ -791,6 +791,7 @@ class Shell:
         opened: list[TextIO] = []
         try:
             for fd, op, target in redirections:
+                target = normalize_redirection_target(target)
                 if op in {"<", "<&"} and op == "<":
                     file = open(target, "r", encoding="utf-8", errors="replace")
                     opened.append(file)
@@ -838,7 +839,20 @@ class Shell:
         status = 0
         buffer = ""
         while True:
-            prompt = self.get_parameter("PS2") if buffer else self.get_parameter("PS1") or "$ "
+            prompt_source = self.get_parameter("PS2") if buffer else self.get_parameter("PS1") or "$ "
+            try:
+                prompt = self.expand_prompt(prompt_source)
+            except KeyboardInterrupt:
+                self.stdout.write("\n")
+                buffer = ""
+                status = 130
+                self.last_status = status
+                continue
+            except ExpansionError as exc:
+                self.stderr.write(f"{self.argv0}: {exc}\n")
+                prompt = prompt_source
+                status = 2
+                self.last_status = status
             try:
                 line = input(prompt)
             except EOFError:
@@ -877,6 +891,9 @@ class Shell:
                 self.last_status = status
             buffer = ""
 
+    def expand_prompt(self, prompt: str) -> str:
+        return chars_to_text(expand_text(self, prompt, quoted=True))
+
     def get_parameter(self, name: str, *, strict: bool = False) -> str:
         if name == "?":
             return str(self.last_status)
@@ -971,6 +988,12 @@ def has_fileno(stream: TextIO) -> bool:
     return True
 
 
+def normalize_redirection_target(target: str) -> str:
+    if os.name == "nt" and target == "/dev/null":
+        return os.devnull
+    return target
+
+
 def stop_process_after_interrupt(process: subprocess.Popen[str]) -> None:
     try:
         process.wait(timeout=0.2)

{py_posix_shell-0.4.2 → py_posix_shell-0.4.3}/tests/test_shell.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import base64
 import io
 import os
 import sys
@@ -394,6 +395,118 @@ def test_repl_keyboard_interrupt_returns_to_prompt(monkeypatch):
     assert stdout.getvalue() == "\nafter:130\n\n"
 
 
+def test_py_web_ssh_cwd_prompt_injection_without_native_utilities(monkeypatch, tmp_path):
+    token = "testtoken"
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    old_cwd = os.getcwd()
+    os.chdir(tmp_path)
+    try:
+        (tmp_path / "visible.txt").write_text("visible\n", encoding="utf-8")
+        shell = Shell(stdout=stdout, stderr=stderr, env={"PATH": ""}, interactive=True)
+        commands = (
+            "__py_web_ssh_cwd_armed=; "
+            "__py_web_ssh_cwd_ready(){ "
+            "[ -n \"${__py_web_ssh_cwd_armed-}\" ] || return; "
+            "printf '\\033]6970;ready;testtoken=1\\007' >&2; "
+            "}",
+            "__py_web_ssh_cwd_list(){ "
+            "[ -n \"${__py_web_ssh_cwd_armed-}\" ] || return; "
+            "__py_web_ssh_cwd_ls=$(LC_ALL=C command ls -al 2>&1 | command base64 | command tr -d '\\r\\n') || __py_web_ssh_cwd_ls=; "
+            "printf '\\033]6970;ls;testtoken=%s\\007' \"$__py_web_ssh_cwd_ls\" >&2; "
+            "}",
+            "__py_web_ssh_cwd_report(){ "
+            "[ -n \"${__py_web_ssh_cwd_armed-}\" ] || return; "
+            "__py_web_ssh_cwd_now=$(command pwd 2>/dev/null || printf '%s' \"$PWD\") || return; "
+            "if [ \"${__py_web_ssh_cwd_now}\" != \"${__py_web_ssh_cwd_last-}\" ]; then "
+            "__py_web_ssh_cwd_last=$__py_web_ssh_cwd_now; "
+            "printf '\\033]6970;cwd;testtoken=%s\\007' \"$__py_web_ssh_cwd_now\" >&2; "
+            "__py_web_ssh_cwd_list; "
+            "fi; "
+            "__py_web_ssh_cwd_ready; "
+            "}",
+            "if [ -n \"${BASH_VERSION:-}\" ]; then "
+            "PROMPT_COMMAND=\"__py_web_ssh_cwd_report${PROMPT_COMMAND:+;$PROMPT_COMMAND}\"; "
+            "elif [ -n \"${ZSH_VERSION:-}\" ]; then "
+            "autoload -Uz add-zsh-hook 2>/dev/null && add-zsh-hook precmd __py_web_ssh_cwd_report || "
+            "precmd_functions+=(__py_web_ssh_cwd_report); "
+            "else "
+            "__py_web_ssh_cwd_prompt=; "
+            "PS1='${__py_web_ssh_cwd_prompt:-$(__py_web_ssh_cwd_report)}'\"${PS1-}\"; "
+            "PS2='${__py_web_ssh_cwd_prompt:-$(__py_web_ssh_cwd_report)}'\"${PS2-}\"; "
+            "fi",
+        )
+        for command in commands:
+            assert shell.execute(command) == 0, stderr.getvalue()
+        assert shell.execute("__py_web_ssh_cwd_armed=1") == 0
+        stderr.seek(0)
+        stderr.truncate(0)
+        prompts: list[str] = []
+
+        def fake_input(prompt):
+            prompts.append(prompt)
+            raise EOFError
+
+        monkeypatch.setattr("builtins.input", fake_input)
+
+        assert shell.repl() == 0
+        hidden = stderr.getvalue()
+        assert prompts == [""]
+        assert f"\x1b]6970;cwd;{token}=".encode().decode() in hidden
+        assert f"\x1b]6970;ls;{token}=" in hidden
+        assert f"\x1b]6970;ready;{token}=1\x07" in hidden
+        listing_payload = hidden.split(f"\x1b]6970;ls;{token}=", 1)[1].split("\x07", 1)[0]
+        listing_text = base64.b64decode(listing_payload).decode("utf-8", errors="replace")
+        visible_line = next(line for line in listing_text.splitlines() if line.endswith(" visible.txt"))
+        assert len(visible_line.split(maxsplit=8)) == 9
+    finally:
+        os.chdir(old_cwd)
+
+
+def test_py_web_ssh_base64_transfer_commands_without_native_utilities(tmp_path):
+    raw = b"\x00hello\r\nweb-ssh\xff"
+    source = tmp_path / "source.bin"
+    encoded = tmp_path / "source.b64"
+    decoded_d = tmp_path / "decoded-d.bin"
+    decoded_bsd = tmp_path / "decoded-bsd.bin"
+    size_path = tmp_path / "size.txt"
+    temp = tmp_path / "upload.tmp"
+    final = tmp_path / "final.bin"
+    b64_temp = tmp_path / "upload.b64"
+    err = tmp_path / "upload.tmp.err"
+    source.write_bytes(raw)
+    b64_temp.write_bytes(base64.b64encode(raw))
+    script = f'''
+command base64 < "{source}" | command tr -d '\\r\\n' > "{encoded}"
+command base64 -d < "{encoded}" > "{decoded_d}"
+command base64 -D < "{encoded}" > "{decoded_bsd}"
+if [ -f "{source}" ]; then wc -c < "{source}" > "{size_path}"; else exit 2; fi
+set -e
+rm -f "{temp}" "{err}"
+if command base64 -d < "{b64_temp}" > "{temp}" 2> "{err}"; then
+  :
+elif command base64 -D < "{b64_temp}" > "{temp}" 2> "{err}"; then
+  :
+else
+  cat "{err}" >&2
+  exit 1
+fi
+mv -f "{temp}" "{final}"
+rm -f "{b64_temp}" "{err}"
+'''
+    status, stdout, stderr, _shell = run_shell(script, env={"PATH": ""})
+    assert status == 0
+    assert stdout == ""
+    assert stderr == ""
+    assert base64.b64decode(encoded.read_bytes()) == raw
+    assert decoded_d.read_bytes() == raw
+    assert decoded_bsd.read_bytes() == raw
+    assert int(size_path.read_text(encoding="utf-8").strip()) == len(raw)
+    assert final.read_bytes() == raw
+    assert not b64_temp.exists()
+    assert not err.exists()
+
+
 def test_internal_extended_text_utilities_without_path(tmp_path):
     data = tmp_path / "data.txt"
     csv = tmp_path / "data.csv"