@caupulican/pi-adaptative 0.81.41 → 0.81.43

package/dist/bundled-resources/runtimes/pi-shell-engine/commands/text.py

@@ -68,6 +68,40 @@ def _refuse_flag(name: str, flag: str) -> None:
     )
 
 
+def _parse_simple_flags(
+    ctx: "BuiltinContext", name: str, known_flags: set[str], max_operands: int | None
+) -> tuple[list[str], list[str]]:
+    flags: list[str] = []
+    operands: list[str] = []
+    for arg in ctx.argv[1:]:
+        if arg == "--":
+            continue
+        if arg.startswith("-") and arg != "-":
+            if arg not in known_flags:
+                _refuse_flag(name, arg)
+            flags.append(arg)
+        else:
+            operands.append(arg)
+    if max_operands is not None and len(operands) > max_operands:
+        _refuse_flag(name, "multi-file")
+    return flags, operands
+
+
+def _decode_text_lines(data: bytes) -> list[str]:
+    text = data.decode("utf-8", errors="surrogateescape")
+    lines = text.split("\n")
+    if text.endswith("\n"):
+        lines.pop()
+    return lines
+
+
+def _write_text_lines(ctx: "BuiltinContext", lines: list[str]) -> None:
+    if not lines:
+        return
+    ctx.stdout.write("\n".join(lines).encode("utf-8", errors="surrogateescape"))
+    ctx.stdout.write(b"\n")
+
+
 # --- cat ---------------------------------------------------------------------
 
 
@@ -97,7 +131,7 @@ def cat(ctx: "BuiltinContext") -> int:
 
 
 def _parse_n_flag(name: str, argv: list[str]) -> tuple[int, list[str]]:
-    """Parse `[-n N] [FILE]` only. Any other flag/form -> unsupported-flag."""
+    """Parse `[-n N|-N] [FILE]`. Any other flag/form -> unsupported-flag."""
     n = 10
     operands: list[str] = []
     args = argv[1:]
@@ -118,6 +152,10 @@ def _parse_n_flag(name: str, argv: list[str]) -> tuple[int, list[str]]:
             n = _parse_int_operand(name, a[2:])
             i += 1
             continue
+        if len(a) > 1 and a[0] == "-" and a[1:].isdigit():
+            n = int(a[1:])
+            i += 1
+            continue
         if a.startswith("-") and a != "-":
             _refuse_flag(name, a)
         operands.append(a)
@@ -179,21 +217,9 @@ def _wc_counts(data: bytes) -> tuple[int, int, int, int]:
 
 
 def wc(ctx: "BuiltinContext") -> int:
-    known_single = {"-l", "-w", "-c", "-m"}
-    flags: list[str] = []
-    operands: list[str] = []
-    for a in ctx.argv[1:]:
-        if a == "--":
-            continue
-        if a.startswith("-") and a != "-":
-            if a not in known_single:
-                _refuse_flag("wc", a)
-            flags.append(a)
-        else:
-            operands.append(a)
-
-    if len(operands) > 1:
-        _refuse_flag("wc", "multi-file")
+    flags, operands = _parse_simple_flags(
+        ctx, "wc", {"-l", "-w", "-c", "-m"}, 1
+    )
 
     single_flag = len(flags) == 1 and not operands
     if single_flag:
@@ -233,26 +259,12 @@ def wc(ctx: "BuiltinContext") -> int:
 
 
 def sort(ctx: "BuiltinContext") -> int:
-    flags: list[str] = []
-    operands: list[str] = []
-    for a in ctx.argv[1:]:
-        if a == "--":
-            continue
-        if a.startswith("-") and a != "-":
-            if a not in {"-r", "-n", "-u", "-f"}:
-                _refuse_flag("sort", a)
-            flags.append(a)
-        else:
-            operands.append(a)
-    if len(operands) > 1:
-        _refuse_flag("sort", "multi-file")
+    flags, operands = _parse_simple_flags(
+        ctx, "sort", {"-r", "-n", "-u", "-f"}, 1
+    )
 
     data = _read_operand_or_stdin(ctx, operands)
-    text = data.decode("utf-8", errors="surrogateescape")
-    had_trailing_newline = text.endswith("\n")
-    lines = text.split("\n")
-    if had_trailing_newline:
-        lines = lines[:-1]
+    lines = _decode_text_lines(data)
 
     reverse = "-r" in flags
     numeric = "-n" in flags
@@ -280,10 +292,7 @@ def sort(ctx: "BuiltinContext") -> int:
                 deduped.append(line)
         lines = deduped
 
-    out = "\n".join(lines)
-    if lines:
-        out += "\n"
-    ctx.stdout.write(out.encode("utf-8", errors="surrogateescape"))
+    _write_text_lines(ctx, lines)
     return 0
 
 
@@ -291,26 +300,12 @@ def sort(ctx: "BuiltinContext") -> int:
 
 
 def uniq(ctx: "BuiltinContext") -> int:
-    flags: list[str] = []
-    operands: list[str] = []
-    for a in ctx.argv[1:]:
-        if a == "--":
-            continue
-        if a.startswith("-") and a != "-":
-            if a not in {"-c", "-d", "-u", "-i"}:
-                _refuse_flag("uniq", a)
-            flags.append(a)
-        else:
-            operands.append(a)
-    if len(operands) > 1:
-        _refuse_flag("uniq", "multi-file")
+    flags, operands = _parse_simple_flags(
+        ctx, "uniq", {"-c", "-d", "-u", "-i"}, 1
+    )
 
     data = _read_operand_or_stdin(ctx, operands)
-    text = data.decode("utf-8", errors="surrogateescape")
-    had_trailing_newline = text.endswith("\n")
-    lines = text.split("\n")
-    if had_trailing_newline:
-        lines = lines[:-1]
+    lines = _decode_text_lines(data)
 
     ignore_case = "-i" in flags
     count_flag = "-c" in flags
@@ -340,10 +335,7 @@ def uniq(ctx: "BuiltinContext") -> int:
     else:
         out_lines = [line for line, _ in groups]
 
-    out = "\n".join(out_lines)
-    if out_lines:
-        out += "\n"
-    ctx.stdout.write(out.encode("utf-8", errors="surrogateescape"))
+    _write_text_lines(ctx, out_lines)
     return 0
 
 
@@ -437,11 +429,7 @@ def cut(ctx: "BuiltinContext") -> int:
         _refuse_flag("cut", "multi-file")
 
     data = _read_operand_or_stdin(ctx, operands)
-    text = data.decode("utf-8", errors="surrogateescape")
-    had_trailing_newline = text.endswith("\n")
-    lines = text.split("\n")
-    if had_trailing_newline:
-        lines = lines[:-1]
+    lines = _decode_text_lines(data)
 
     out_lines: list[str] = []
     if field_spec is not None:
@@ -456,10 +444,7 @@ def cut(ctx: "BuiltinContext") -> int:
             selected_chars = [c for idx, c in enumerate(line, start=1) if _in_ranges(idx, ranges)]
             out_lines.append("".join(selected_chars))
 
-    out = "\n".join(out_lines)
-    if out_lines:
-        out += "\n"
-    ctx.stdout.write(out.encode("utf-8", errors="surrogateescape"))
+    _write_text_lines(ctx, out_lines)
     return 0
 
 
@@ -499,17 +484,9 @@ def _expand_tr_set(spec: str) -> str:
 
 
 def tr(ctx: "BuiltinContext") -> int:
-    flags: list[str] = []
-    operands: list[str] = []
-    for a in ctx.argv[1:]:
-        if a == "--":
-            continue
-        if a.startswith("-") and a != "-":
-            if a not in {"-d", "-s", "-c"}:
-                _refuse_flag("tr", a)
-            flags.append(a)
-        else:
-            operands.append(a)
+    flags, operands = _parse_simple_flags(
+        ctx, "tr", {"-d", "-s", "-c"}, None
+    )
 
     delete = "-d" in flags
     squeeze = "-s" in flags

package/dist/bundled-resources/runtimes/pi-shell-engine/context.py

@@ -46,7 +46,7 @@ class ExecContext:
     stderr: BinaryIO | int | None = None
 
 
-# Frozen inline sets: state mutators and the runner builtin are NOT in commands/REGISTRY;
-# exec.py handles them inline because they need ShellState / the executor.
-STATE_BUILTINS = {"cd", "export", "unset"}
+# Executor-owned builtins are NOT in commands/REGISTRY: state mutators and `exit`
+# need ShellState/control-flow access, while the runner needs the executor.
+STATE_BUILTINS = {"cd", "export", "unset", "exit"}
 RUNNER_BUILTINS = {"xargs"}

package/dist/bundled-resources/runtimes/pi-shell-engine/errors.py

@@ -47,3 +47,11 @@ class UnsupportedConstruct(Exception):
         self.code = "unsupported"
         self.construct = construct
         self.message = message
+
+
+class ShellExit(Exception):
+    """Controlled `exit` request carried to the nearest shell boundary."""
+
+    def __init__(self, exit_code: int) -> None:
+        super().__init__(exit_code)
+        self.exit_code = exit_code

package/dist/bundled-resources/runtimes/pi-shell-engine/escapes.py

@@ -0,0 +1,70 @@
+"""One-pass backslash escape decoding with explicit shell-language policies."""
+
+from __future__ import annotations
+
+ANSI_C_ESCAPES = 0
+ECHO_ESCAPES = 1
+PRINTF_ESCAPES = 2
+
+_SIMPLE_ESCAPES = {
+    "\\": "\\",
+    "a": "\a",
+    "b": "\b",
+    "e": "\x1b",
+    "f": "\f",
+    "n": "\n",
+    "r": "\r",
+    "t": "\t",
+    "v": "\v",
+}
+
+
+def decode_backslash_escapes(text: str, mode: int) -> tuple[str, bool]:
+    r"""Decode one string without rescanning prefixes; bool signals echo's ``\c``."""
+    out: list[str] = []
+    i = 0
+    while i < len(text):
+        char = text[i]
+        if char != "\\" or i + 1 >= len(text):
+            out.append(char)
+            i += 1
+            continue
+        escaped = text[i + 1]
+        simple = _SIMPLE_ESCAPES.get(escaped)
+        if simple is not None:
+            out.append(simple)
+            i += 2
+            continue
+        if escaped == "c":
+            if mode == ECHO_ESCAPES:
+                return "".join(out), True
+            if mode == PRINTF_ESCAPES:
+                out.append("\\c")
+            i += 2
+            continue
+        if escaped == "0":
+            end = i + 2
+            while end < len(text) and end < i + 5 and text[end] in "01234567":
+                end += 1
+            digits = text[i + 2 : end]
+            value = int(digits, 8) if digits else 0
+            out.append(chr(value if mode == ANSI_C_ESCAPES else value & 0xFF))
+            i = end
+            continue
+        if escaped == "x":
+            end = i + 2
+            while end < len(text) and end < i + 4 and text[end] in "0123456789abcdefABCDEF":
+                end += 1
+            digits = text[i + 2 : end]
+            if digits:
+                value = int(digits, 16)
+                out.append(chr(value if mode == ANSI_C_ESCAPES else value & 0xFF))
+            else:
+                out.append("x" if mode == ANSI_C_ESCAPES else "\\x")
+            i = end
+            continue
+        if mode != ANSI_C_ESCAPES:
+            out.append("\\")
+        out.append(escaped)
+        i += 2
+    return "".join(out), False

package/dist/bundled-resources/runtimes/pi-shell-engine/exec.py

@@ -17,7 +17,7 @@ import parser as parser_module
 import proc
 import tokens as tokens_module
 from context import RUNNER_BUILTINS, STATE_BUILTINS, BuiltinContext, ExecContext
-from errors import UnsupportedConstruct
+from errors import ShellExit, UnsupportedConstruct
 from state import ShellState
 
 DEVNULL = os.devnull
@@ -119,41 +119,50 @@ def _real_fd(stream: BinaryIO | int) -> int | None:
         return None
 
 
-def _prepare_child_output(stream: BinaryIO | int) -> _ChildStream:
+def _direct_child_stream(stream: BinaryIO | int) -> _ChildStream | None:
     fd = _real_fd(stream)
-    if fd is not None:
-        return _ChildStream(fd, owns_fd=False)
-    assert not isinstance(stream, int)
-    read_fd, write_fd = os.pipe()
+    return _ChildStream(fd, owns_fd=False) if fd is not None else None
 
-    def pump() -> None:
-        with os.fdopen(read_fd, "rb", closefd=True) as reader:
-            while True:
-                chunk = reader.read(65536)
-                if not chunk:
-                    break
-                stream.write(chunk)
 
-    thread = threading.Thread(target=pump, daemon=True)
-    thread.start()
-    return _ChildStream(write_fd, owns_fd=True, join=thread.join)
+def _copy_stream(source: BinaryIO, target: BinaryIO) -> None:
+    while True:
+        chunk = source.read(65536)
+        if not chunk:
+            return
+        target.write(chunk)
 
 
-def _prepare_child_input(stream: BinaryIO | int) -> _ChildStream:
-    fd = _real_fd(stream)
-    if fd is not None:
-        return _ChildStream(fd, owns_fd=False)
+def _prepare_child_stream(stream: BinaryIO | int, *, child_reads: bool) -> _ChildStream:
+    direct = _direct_child_stream(stream)
+    if direct is not None:
+        return direct
     assert not isinstance(stream, int)
-    data = stream.read()
     read_fd, write_fd = os.pipe()
 
-    def feed() -> None:
-        with os.fdopen(write_fd, "wb", closefd=True) as writer:
-            writer.write(data)
+    if child_reads:
+        def bridge() -> None:
+            with os.fdopen(write_fd, "wb", closefd=True) as writer:
+                _copy_stream(stream, writer)
+
+        child_fd = read_fd
+    else:
+        def bridge() -> None:
+            with os.fdopen(read_fd, "rb", closefd=True) as reader:
+                _copy_stream(reader, stream)
+
+        child_fd = write_fd
 
-    thread = threading.Thread(target=feed, daemon=True)
+    thread = threading.Thread(target=bridge, daemon=True)
     thread.start()
-    return _ChildStream(read_fd, owns_fd=True, join=thread.join)
+    return _ChildStream(child_fd, owns_fd=True, join=thread.join)
+
+
+def _prepare_child_output(stream: BinaryIO | int) -> _ChildStream:
+    return _prepare_child_stream(stream, child_reads=False)
+
+
+def _prepare_child_input(stream: BinaryIO | int) -> _ChildStream:
+    return _prepare_child_stream(stream, child_reads=True)
 
 
 def _spawn_with_bridges(
@@ -185,6 +194,39 @@ def _spawn_with_bridges(
     return child, in_prep, out_prep, err_prep
 
 
+def _spawn_argv_or_report(
+    argv: list[str],
+    state: ShellState,
+    ctx: ExecContext,
+    stdin_stream: BinaryIO | int,
+    stdout_stream: BinaryIO | int,
+    stderr_stream: BinaryIO | int,
+) -> tuple["subprocess.Popen[bytes]", _ChildStream, _ChildStream, _ChildStream] | None:
+    try:
+        return _spawn_with_bridges(
+            argv,
+            state,
+            stdin_stream,
+            stdout_stream,
+            stderr_stream,
+            ctx.deadline,
+        )
+    except FileNotFoundError:
+        message = f"{argv[0]}: command not found\n"
+        _write_merged(
+            stderr_stream, message.encode("utf-8", errors="replace"), ctx
+        )
+        return None
+
+
+def _command_scratch_state(command: nodes.SimpleCommand, ctx: ExecContext) -> ShellState:
+    return ShellState(
+        cwd=ctx.state.cwd,
+        env=_apply_transient_assignments(command, ctx),
+        powershell_path=ctx.state.powershell_path,
+    )
+
+
 def _finish_bridges(*preps: _ChildStream) -> None:
     for prep in preps:
         if prep.join is not None:
@@ -209,6 +251,7 @@ def execute(list_node: nodes.CommandList, ctx: ExecContext) -> int:
     exit_code = 0
     for entry in list_node.entries:
         exit_code = _execute_andor(entry, ctx)
+        ctx.state.last_exit_code = exit_code
     return exit_code
 
 
@@ -222,6 +265,7 @@ def _execute_andor(andor: nodes.AndOr, ctx: ExecContext) -> int:
             if operator == "||" and exit_code == 0:
                 continue
         exit_code = _execute_pipeline(pipeline, ctx)
+        ctx.state.last_exit_code = exit_code
     return exit_code
 
 
@@ -310,6 +354,8 @@ def _run_pipeline_elements(elements: list, ctx: ExecContext) -> int:
                     # fabricated exit-0/empty-output success.
                     refusals[idx] = exc
                     results[idx] = 1
+                except ShellExit as exc:
+                    results[idx] = exc.exit_code
                 except BaseException as exc:  # noqa: BLE001 - any other stage failure must not crash the engine
                     # Any OTHER exception is a real per-stage failure, not a refusal: it
                     # gets a named, actionable one-line message on the merged sink (never
@@ -403,16 +449,12 @@ def _spawn_external_stage(
     try:
         r_in, r_out, r_err = _apply_redirects(command.redirects, ctx, stdin_stream, stdout_stream, stderr_base, tracker)
         argv = _expand_argv(command, ctx)
-        env = _apply_transient_assignments(command, ctx)
-        scratch_state = ShellState(cwd=ctx.state.cwd, env=env)
-        try:
-            child, in_prep, out_prep, err_prep = _spawn_with_bridges(
-                argv, scratch_state, r_in, r_out, r_err, ctx.deadline
-            )
-        except FileNotFoundError:
-            message = f"{argv[0]}: command not found\n"
-            _write_merged(stderr_base, message.encode("utf-8", errors="replace"), ctx)
+        spawned = _spawn_argv_or_report(
+            argv, _command_scratch_state(command, ctx), ctx, r_in, r_out, r_err
+        )
+        if spawned is None:
             return None
+        child, in_prep, out_prep, err_prep = spawned
         return child, (in_prep, out_prep, err_prep)
     finally:
         tracker.close()
@@ -469,29 +511,42 @@ def _sub_ctx(
     )
 
 
-def _execute_subshell(node: nodes.Subshell, ctx: ExecContext, stdin_stream, stdout_stream, stderr_stream) -> int:
+def _execute_redirected_group(
+    node: nodes.Subshell | nodes.BraceGroup,
+    ctx: ExecContext,
+    stdin_stream,
+    stdout_stream,
+    stderr_stream,
+    *,
+    isolated: bool,
+) -> int:
     tracker = _Redirected()
     try:
         r_in, r_out, r_err = _apply_redirects(
             node.redirects, ctx, stdin_stream, stdout_stream, stderr_stream, tracker
         )
-        isolated_state = ctx.state.copy()
-        inner_ctx = _sub_ctx(ctx, isolated_state, r_in, r_out, r_err)
-        return execute(node.body, inner_ctx)
+        state = ctx.state.copy() if isolated else ctx.state
+        inner_ctx = _sub_ctx(ctx, state, r_in, r_out, r_err)
+        try:
+            return execute(node.body, inner_ctx)
+        except ShellExit as exc:
+            if isolated:
+                return exc.exit_code
+            raise
     finally:
         tracker.close()
 
 
+def _execute_subshell(node: nodes.Subshell, ctx: ExecContext, stdin_stream, stdout_stream, stderr_stream) -> int:
+    return _execute_redirected_group(
+        node, ctx, stdin_stream, stdout_stream, stderr_stream, isolated=True
+    )
+
+
 def _execute_brace_group(node: nodes.BraceGroup, ctx: ExecContext, stdin_stream, stdout_stream, stderr_stream) -> int:
-    tracker = _Redirected()
-    try:
-        r_in, r_out, r_err = _apply_redirects(
-            node.redirects, ctx, stdin_stream, stdout_stream, stderr_stream, tracker
-        )
-        inner_ctx = _sub_ctx(ctx, ctx.state, r_in, r_out, r_err)
-        return execute(node.body, inner_ctx)
-    finally:
-        tracker.close()
+    return _execute_redirected_group(
+        node, ctx, stdin_stream, stdout_stream, stderr_stream, isolated=False
+    )
 
 
 def _dispatch_simple_command(
@@ -540,14 +595,12 @@ def _dispatch_simple_command(
             return ctx.builtins[name](builtin_ctx)
 
         # External command.
-        env = _apply_transient_assignments(command, ctx)
-        scratch_state = ShellState(cwd=ctx.state.cwd, env=env)
-        try:
-            child, in_prep, out_prep, err_prep = _spawn_with_bridges(argv, scratch_state, r_in, r_out, r_err, ctx.deadline)
-        except FileNotFoundError:
-            message = f"{name}: command not found\n"
-            _write_merged(r_err, message.encode("utf-8", errors="replace"), ctx)
+        spawned = _spawn_argv_or_report(
+            argv, _command_scratch_state(command, ctx), ctx, r_in, r_out, r_err
+        )
+        if spawned is None:
             return 127
+        child, in_prep, out_prep, err_prep = spawned
         exit_code = proc.wait_with_deadline(child, ctx.deadline)
         _finish_bridges(in_prep, out_prep, err_prep)
         return exit_code
@@ -569,6 +622,19 @@ def _as_stream(fd_or_stream: BinaryIO | int, mode: str) -> BinaryIO:
 
 
 def _run_state_builtin(name: str, argv: list[str], ctx: ExecContext, out_stream: BinaryIO | int) -> int:
+    if name == "exit":
+        if len(argv) > 2:
+            _write_merged(out_stream, b"exit: too many arguments\n", ctx)
+            raise ShellExit(1)
+        if len(argv) == 1:
+            raise ShellExit(ctx.state.last_exit_code)
+        try:
+            exit_code = int(argv[1], 10)
+        except ValueError:
+            _write_merged(out_stream, f"exit: {argv[1]}: numeric argument required\n".encode("utf-8"), ctx)
+            raise ShellExit(2)
+        raise ShellExit(exit_code & 0xFF)
+
     if name == "cd":
         target = argv[1] if len(argv) > 1 else ctx.state.env.get("HOME")
         print_new_cwd = argv[1:2] == ["-"]
@@ -685,14 +751,17 @@ def _run_xargs_batch(argv: list[str], ctx: ExecContext, out_stream: BinaryIO | i
         return ctx.builtins[name](builtin_ctx)
     if name in STATE_BUILTINS:
         return _run_state_builtin(name, argv, ctx, out_stream)
-    scratch_state = ShellState(cwd=ctx.state.cwd, env=ctx.state.env.copy())
-    try:
-        child, in_prep, out_prep, err_prep = _spawn_with_bridges(
-            argv, scratch_state, subprocess.DEVNULL, out_stream, out_stream, ctx.deadline
-        )
-    except FileNotFoundError:
-        _write_merged(out_stream, f"{name}: command not found\n".encode("utf-8"), ctx)
+    scratch_state = ShellState(
+        cwd=ctx.state.cwd,
+        env=ctx.state.env.copy(),
+        powershell_path=ctx.state.powershell_path,
+    )
+    spawned = _spawn_argv_or_report(
+        argv, scratch_state, ctx, subprocess.DEVNULL, out_stream, out_stream
+    )
+    if spawned is None:
         return 127
+    child, in_prep, out_prep, err_prep = spawned
     exit_code = proc.wait_with_deadline(child, ctx.deadline)
     _finish_bridges(in_prep, out_prep, err_prep)
     return exit_code
@@ -729,6 +798,9 @@ def run_command_substitution(src: str, ctx: ExecContext) -> tuple[str, int]:
         deadline=ctx.deadline,
         stderr=ctx.stderr,
     )
-    exit_code = execute(ast, sub_ctx)
+    try:
+        exit_code = execute(ast, sub_ctx)
+    except ShellExit as exc:
+        exit_code = exc.exit_code
     text = buffer.getvalue().decode("utf-8", errors="replace")
     return text.rstrip("\n"), exit_code

package/dist/bundled-resources/runtimes/pi-shell-engine/expand.py

@@ -97,6 +97,9 @@ def _resolve_param(name: str, op: str | None, arg: Word | None, ctx: "ExecContex
     split_and_glob_eligible is False here always; callers decide splitting based on
     quoting context (Raw vs DQ), not on the parameter's own nature.
     """
+    if name == "?" and op is None:
+        return str(ctx.state.last_exit_code), False
+
     env = ctx.state.env
     if op == "#len":
         value = env.get(name, "")