@caupulican/pi-adaptative 0.81.37 → 0.81.39

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

@@ -0,0 +1,287 @@
+"""Token list -> command AST; raises `UnsupportedConstruct` for banned grammar.
+
+`parse(tokens) -> CommandList` per windows-shell-workpackages-2026-07-19.md §1.4. Never
+returns a partial/guessed tree: any construct outside the frozen grammar raises
+`UnsupportedConstruct` with the matching catalog id and an actionable message naming the
+construct.
+"""
+
+from __future__ import annotations
+
+import re
+
+from errors import UnsupportedConstruct
+from nodes import (
+    AndOr,
+    BraceGroup,
+    CommandList,
+    DQ,
+    Lit,
+    Pipeline,
+    PipelineElement,
+    Raw,
+    Redirect,
+    SimpleCommand,
+    Subshell,
+    Word,
+)
+from tokens import Token
+
+_ASSIGNMENT_RE = re.compile(r"^([A-Za-z_][A-Za-z0-9_]*)=(.*)$", re.DOTALL)
+_EXTGLOB_RE = re.compile(r"[@!?*+]\(")
+_BRACE_EXPANSION_RE = re.compile(r"\{[^{}]*,[^{}]*\}")
+
+_JOB_CONTROL_WORDS = {"fg", "bg", "jobs", "wait", "disown"}
+_CONTROL_FLOW_WORDS = {"if", "for", "while", "until", "case", "select"}
+_ARITHMETIC_WORDS = {"let"}
+_UNSUPPORTED_BUILTIN_WORDS = {"eval", "source", ".", "alias", "trap", "set", "shopt", "read", "declare", "local"}
+_NESTED_SHELL_WORDS = {"bash", "sh", "zsh", "fish", "cmd", "powershell", "pwsh", "wsl"}
+
+
+def _literal_text_from_segments(segments: list) -> str | None:
+    parts: list[str] = []
+    for seg in segments:
+        if isinstance(seg, Lit):
+            parts.append(seg.text)
+        elif isinstance(seg, Raw):
+            parts.append(seg.text)
+        elif isinstance(seg, DQ):
+            inner = _literal_text_from_segments(seg.segments)
+            if inner is None:
+                return None
+            parts.append(inner)
+        else:
+            return None
+    return "".join(parts)
+
+
+def _literal_text(word: Word) -> str | None:
+    return _literal_text_from_segments(word.segments)
+
+
+def _check_word_banned_patterns(word: Word) -> None:
+    for seg in word.segments:
+        if isinstance(seg, Raw):
+            if _EXTGLOB_RE.search(seg.text):
+                raise UnsupportedConstruct(
+                    "extended-glob", "Extended glob patterns ('@(...)','!(...)', etc.) are not supported."
+                )
+            if _BRACE_EXPANSION_RE.search(seg.text):
+                raise UnsupportedConstruct(
+                    "brace-expansion", "Brace expansion ('{a,b,c}') is not supported; list the values explicitly."
+                )
+
+
+def _check_command_word_banned(text: str) -> None:
+    if text in _JOB_CONTROL_WORDS:
+        raise UnsupportedConstruct("job-control", f"Job control ('{text}') is not supported.")
+    if text in _CONTROL_FLOW_WORDS:
+        raise UnsupportedConstruct(
+            "control-flow", f"Compound control-flow commands ('{text}') are not supported."
+        )
+    if text in _ARITHMETIC_WORDS:
+        raise UnsupportedConstruct("arithmetic-expansion", f"Arithmetic command '{text}' is not supported.")
+    if text == "function":
+        raise UnsupportedConstruct("function-definition", "Function definitions are not supported.")
+    if text == "exec":
+        raise UnsupportedConstruct("exec-builtin", "The 'exec' builtin is not supported.")
+    if text in _UNSUPPORTED_BUILTIN_WORDS:
+        raise UnsupportedConstruct("unsupported-builtin", f"The '{text}' builtin is not supported.")
+    if text in _NESTED_SHELL_WORDS:
+        raise UnsupportedConstruct(
+            "nested-shell", f"Nesting another shell ('{text}') is not supported; run the command directly."
+        )
+    if text.endswith(".sh") or text.startswith("/bin/"):
+        raise UnsupportedConstruct("posix-script", f"Invoking a script/path directly ('{text}') is not supported.")
+
+
+_REDIRECT_OP_RE = re.compile(r"^(\d*)(.*)$", re.DOTALL)
+_DUP_SUFFIX_RE = re.compile(r"&(\d+)$")
+
+
+def _is_redirect_op_text(text: str) -> bool:
+    return "<" in text or ">" in text
+
+
+class _Parser:
+    def __init__(self, toks: list[Token]) -> None:
+        self.toks = toks
+        self.i = 0
+
+    def peek(self) -> Token | None:
+        return self.toks[self.i] if self.i < len(self.toks) else None
+
+    def peek_at(self, offset: int) -> Token | None:
+        j = self.i + offset
+        return self.toks[j] if j < len(self.toks) else None
+
+    def advance(self) -> Token:
+        tok = self.toks[self.i]
+        self.i += 1
+        return tok
+
+    def at_op(self, text: str) -> bool:
+        tok = self.peek()
+        return tok is not None and tok.kind == "OP" and tok.text == text
+
+    def _skip_seps(self) -> None:
+        while self.at_op(";") or self.at_op("\n"):
+            self.advance()
+
+    def parse_command_list(self, stop_texts: frozenset[str]) -> CommandList:
+        entries = []
+        separators: list[str] = []
+        self._skip_seps()
+        while True:
+            tok = self.peek()
+            if tok is None or (tok.kind == "OP" and tok.text in stop_texts):
+                break
+            entries.append(self.parse_and_or())
+            if self.at_op("&"):
+                raise UnsupportedConstruct(
+                    "job-control", "Background execution ('&') is not supported; run commands synchronously."
+                )
+            tok = self.peek()
+            if tok is None or (tok.kind == "OP" and tok.text in stop_texts):
+                break
+            if tok.kind == "OP" and tok.text in (";", "\n"):
+                separators.append(self.advance().text)  # type: ignore[arg-type]
+                self._skip_seps()
+                continue
+            raise UnsupportedConstruct(
+                "malformed-syntax", f"Unexpected token in command list: {tok!r}."
+            )
+        return CommandList(entries=entries, separators=separators)
+
+    def parse_and_or(self) -> AndOr:
+        pipelines = [self.parse_pipeline()]
+        operators: list[str] = []
+        while self.at_op("&&") or self.at_op("||"):
+            operators.append(self.advance().text)  # type: ignore[arg-type]
+            while self.at_op("\n"):
+                self.advance()
+            pipelines.append(self.parse_pipeline())
+        return AndOr(pipelines=pipelines, operators=operators)
+
+    def parse_pipeline(self) -> Pipeline:
+        negated = False
+        tok = self.peek()
+        if tok is not None and tok.kind == "WORD" and _literal_text_from_segments(tok.segments or []) == "!":
+            negated = True
+            self.advance()
+        elements: list[PipelineElement] = [self.parse_pipeline_element()]
+        while self.at_op("|"):
+            self.advance()
+            while self.at_op("\n"):
+                self.advance()
+            elements.append(self.parse_pipeline_element())
+        return Pipeline(elements=elements, negated=negated)
+
+    def parse_pipeline_element(self) -> PipelineElement:
+        if self.at_op("("):
+            self.advance()
+            body = self.parse_command_list(frozenset({")"}))
+            if not self.at_op(")"):
+                raise UnsupportedConstruct("malformed-syntax", "Unterminated subshell: missing closing ')'.")
+            self.advance()
+            redirects = self._parse_redirects()
+            return Subshell(body=body, redirects=redirects)
+        if self.at_op("{"):
+            self.advance()
+            body = self.parse_command_list(frozenset({"}"}))
+            if not self.at_op("}"):
+                raise UnsupportedConstruct("malformed-syntax", "Unterminated brace group: missing closing '}'.")
+            self.advance()
+            redirects = self._parse_redirects()
+            return BraceGroup(body=body, redirects=redirects)
+        command = self.parse_simple_command()
+        if not command.assignments and not command.words and not command.redirects:
+            # A fully empty SimpleCommand reached as a pipeline element means a missing
+            # command word (e.g. "| foo", "a && ", "a | | b"). Assignment-only (`FOO=1`) and
+            # redirect-only (`> file`) commands are valid and never reach here empty.
+            raise UnsupportedConstruct(
+                "malformed-syntax", "Missing command: a pipeline/list element has no command word."
+            )
+        return command
+
+    def _parse_redirects(self) -> list[Redirect]:
+        redirects: list[Redirect] = []
+        while True:
+            tok = self.peek()
+            if tok is not None and tok.kind == "OP" and tok.text is not None and _is_redirect_op_text(tok.text):
+                redirects.append(self._parse_one_redirect())
+                continue
+            break
+        return redirects
+
+    def _parse_one_redirect(self) -> Redirect:
+        tok = self.advance()
+        text = tok.text or ""
+        m = _REDIRECT_OP_RE.match(text)
+        assert m is not None
+        fd_text, _core = m.group(1), m.group(2)
+        fd = int(fd_text) if fd_text else None
+        dup_match = _DUP_SUFFIX_RE.search(text)
+        dup_fd = int(dup_match.group(1)) if dup_match else None
+        target: Word | None = None
+        if dup_fd is None:
+            target_tok = self.peek()
+            if target_tok is None or target_tok.kind != "WORD":
+                raise UnsupportedConstruct("malformed-syntax", f"Redirect '{text}' is missing its target.")
+            self.advance()
+            target = Word(segments=target_tok.segments or [])
+        return Redirect(op=text, fd=fd, target=target, dup_fd=dup_fd)
+
+    def parse_simple_command(self) -> SimpleCommand:
+        assignments: list[tuple[str, Word]] = []
+        words: list[Word] = []
+        redirects: list[Redirect] = []
+        while True:
+            tok = self.peek()
+            if tok is None:
+                break
+            if tok.kind == "OP":
+                if tok.text is not None and _is_redirect_op_text(tok.text):
+                    redirects.append(self._parse_one_redirect())
+                    continue
+                break
+            word = Word(segments=tok.segments or [])
+            if not words:
+                lead = word.segments[0] if word.segments else None
+                if isinstance(lead, Raw):
+                    m = _ASSIGNMENT_RE.match(lead.text)
+                    if m:
+                        self.advance()
+                        name, rest = m.group(1), m.group(2)
+                        value_segments = ([Raw(text=rest)] if rest else []) + list(word.segments[1:])
+                        assignments.append((name, Word(segments=value_segments)))
+                        continue
+            _check_word_banned_patterns(word)
+            if not words:
+                nxt1 = self.peek_at(1)
+                nxt2 = self.peek_at(2)
+                if (
+                    nxt1 is not None
+                    and nxt1.kind == "OP"
+                    and nxt1.text == "("
+                    and nxt2 is not None
+                    and nxt2.kind == "OP"
+                    and nxt2.text == ")"
+                ):
+                    raise UnsupportedConstruct("function-definition", "Function definitions are not supported.")
+                literal = _literal_text(word)
+                if literal is not None:
+                    _check_command_word_banned(literal)
+            words.append(word)
+            self.advance()
+        return SimpleCommand(assignments=assignments, words=words, redirects=redirects)
+
+
+def parse(tokens: list[Token]) -> CommandList:
+    parser = _Parser(tokens)
+    result = parser.parse_command_list(frozenset())
+    if parser.peek() is not None:
+        raise UnsupportedConstruct(
+            "malformed-syntax", f"Unexpected trailing token: {parser.peek()!r}."
+        )
+    return result

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

@@ -0,0 +1,137 @@
+"""External-command spawn: PATHEXT-aware resolution, pipe wiring, deadline-safe kill.
+
+Owned by WP-C. Pure stdlib. See windows-shell-workpackages-2026-07-19.md §3 (WP-C spec).
+"""
+
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import time
+from typing import BinaryIO
+
+from state import ShellState
+
+TIMEOUT_EXIT_CODE = 124
+
+
+def resolve_external(name: str, env: dict[str, str], cwd: str | None = None) -> str | None:
+    """Resolve `name` to an absolute path over `env["PATH"]`, honoring PATHEXT on win32.
+
+    Direct `.exe` (or extension-less on POSIX) targets resolve as-is; `.bat`/`.cmd`
+    targets are still resolved to a path (the caller wraps them via `cmd /c`).
+
+    Thread-safe: pipeline stages may resolve concurrently on threads, so this never
+    reads or mutates `os.environ` (which `shutil.which` does internally for PATH).
+    Manual resolution only, entirely off the request env passed in.
+    """
+    path_value = env.get("PATH", "")
+    if os.path.isabs(name) or os.sep in name or (os.altsep and os.altsep in name):
+        candidate = name if os.path.isabs(name) else os.path.join(cwd or os.getcwd(), name)
+        if os.path.isfile(candidate):
+            return os.path.abspath(candidate)
+        return None
+
+    path_dirs = [d for d in path_value.split(os.pathsep) if d]
+
+    if os.name == "nt":
+        pathext = env.get("PATHEXT") or ".COM;.EXE;.BAT;.CMD"
+        exts = [e for e in pathext.split(os.pathsep) if e]
+        has_ext = any(name.lower().endswith(ext.lower()) for ext in exts)
+        candidates = [name] if has_ext else [name + ext for ext in exts] + [name]
+        for directory in path_dirs:
+            for candidate in candidates:
+                full = os.path.join(directory, candidate)
+                if os.path.isfile(full):
+                    return full
+        return None
+
+    for directory in path_dirs:
+        base_dir = directory if os.path.isabs(directory) else os.path.join(cwd or os.getcwd(), directory)
+        full = os.path.join(base_dir, name)
+        if os.path.isfile(full) and os.access(full, os.X_OK):
+            return full
+    return None
+
+
+def build_argv(resolved_path: str, argv: list[str]) -> list[str]:
+    """Wrap `.bat`/`.cmd` targets via `cmd /c`; direct-exec everything else."""
+    lower = resolved_path.lower()
+    if lower.endswith(".bat") or lower.endswith(".cmd"):
+        return ["cmd", "/c", resolved_path, *argv[1:]]
+    return [resolved_path, *argv[1:]]
+
+
+def spawn_external(
+    argv: list[str],
+    state: ShellState,
+    stdin: BinaryIO | int,
+    stdout: BinaryIO | int,
+    stderr: BinaryIO | int,
+    deadline: float | None,
+) -> "subprocess.Popen[bytes]":
+    """Resolve argv[0] and spawn it (no shell) with the given cwd/env/streams.
+
+    Raises FileNotFoundError if argv[0] does not resolve.
+    """
+    resolved = resolve_external(argv[0], state.env, state.cwd)
+    if resolved is None:
+        raise FileNotFoundError(argv[0])
+    full_argv = build_argv(resolved, argv)
+    kwargs: dict = {}
+    if os.name != "nt":
+        kwargs["start_new_session"] = True
+    else:
+        kwargs["creationflags"] = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
+    return subprocess.Popen(
+        full_argv,
+        cwd=state.cwd,
+        env=dict(state.env),
+        stdin=stdin,
+        stdout=stdout,
+        stderr=stderr,
+        **kwargs,
+    )
+
+
+def kill_process_tree(proc: "subprocess.Popen[bytes]") -> None:
+    """Best-effort kill of `proc` and its children."""
+    if os.name == "nt":
+        subprocess.run(
+            ["taskkill", "/F", "/T", "/PID", str(proc.pid)],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+    else:
+        try:
+            pgid = os.getpgid(proc.pid)
+            os.killpg(pgid, signal.SIGKILL)
+        except (ProcessLookupError, PermissionError, OSError):
+            try:
+                proc.kill()
+            except (ProcessLookupError, OSError):
+                pass
+    try:
+        proc.wait(timeout=5)
+    except Exception:
+        pass
+
+
+def wait_with_deadline(proc: "subprocess.Popen[bytes]", deadline: float | None) -> int:
+    """Wait for `proc`; if `deadline` (a `time.monotonic()` budget) elapses first, kill it.
+
+    Returns the process exit code, or 124 on deadline breach.
+    """
+    if deadline is None:
+        return proc.wait()
+    remaining = deadline - time.monotonic()
+    if remaining <= 0:
+        kill_process_tree(proc)
+        return TIMEOUT_EXIT_CODE
+    try:
+        return proc.wait(timeout=remaining)
+    except subprocess.TimeoutExpired:
+        kill_process_tree(proc)
+        return TIMEOUT_EXIT_CODE

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

@@ -0,0 +1,100 @@
+"""Shell state: current working directory + environment, and delta computation.
+
+Owned by WP-C. Pure stdlib. See windows-shell-workpackages-2026-07-19.md §3 (WP-C spec).
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+
+
+class ShellEnvironment(dict[str, str]):
+    """Windows-compatible environment mapping while preserving the first key spelling."""
+
+    def _existing_key(self, key: object) -> str | None:
+        if not isinstance(key, str) or os.name != "nt":
+            return key if isinstance(key, str) and dict.__contains__(self, key) else None
+        folded = key.casefold()
+        return next((candidate for candidate in dict.keys(self) if candidate.casefold() == folded), None)
+
+    def __contains__(self, key: object) -> bool:
+        return self._existing_key(key) is not None
+
+    def __getitem__(self, key: str) -> str:
+        existing = self._existing_key(key)
+        if existing is None:
+            raise KeyError(key)
+        return dict.__getitem__(self, existing)
+
+    def get(self, key: str, default: str | None = None) -> str | None:
+        existing = self._existing_key(key)
+        return dict.get(self, existing, default) if existing is not None else default
+
+    def __setitem__(self, key: str, value: str) -> None:
+        existing = self._existing_key(key)
+        dict.__setitem__(self, existing or key, value)
+
+    def __delitem__(self, key: str) -> None:
+        existing = self._existing_key(key)
+        if existing is None:
+            raise KeyError(key)
+        dict.__delitem__(self, existing)
+
+    def pop(self, key: str, default=None):
+        existing = self._existing_key(key)
+        if existing is None:
+            return default
+        return dict.pop(self, existing)
+
+    def setdefault(self, key: str, default: str = "") -> str:
+        existing = self._existing_key(key)
+        if existing is not None:
+            return dict.__getitem__(self, existing)
+        dict.__setitem__(self, key, default)
+        return default
+
+    def copy(self) -> "ShellEnvironment":
+        return ShellEnvironment(self)
+
+
+@dataclass
+class ShellState:
+    """Mutable cwd + env carried through a single engine run."""
+
+    cwd: str
+    env: ShellEnvironment = field(default_factory=ShellEnvironment)
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.env, ShellEnvironment):
+            self.env = ShellEnvironment(self.env)
+
+    def copy(self) -> "ShellState":
+        """Return an independent copy (used for subshell isolation)."""
+        return ShellState(cwd=self.cwd, env=self.env.copy())
+
+    def chdir(self, path: str) -> None:
+        """Validate `path` exists and is a directory, then update cwd + OLDPWD."""
+        target = path if os.path.isabs(path) else os.path.join(self.cwd, path)
+        target = os.path.normpath(target)
+        if not os.path.isdir(target):
+            raise FileNotFoundError(target)
+        self.env["OLDPWD"] = self.cwd
+        self.cwd = target
+
+    def setenv(self, name: str, value: str) -> None:
+        self.env[name] = value
+
+    def unsetenv(self, name: str) -> None:
+        self.env.pop(name, None)
+
+    def delta(self, original_env: dict[str, str]) -> dict[str, str | None]:
+        """Compute envDelta vs `original_env`: changed/added -> value, removed -> None."""
+        result: dict[str, str | None] = {}
+        for key, value in self.env.items():
+            if key not in original_env or original_env[key] != value:
+                result[key] = value
+        for key in original_env:
+            if key not in self.env:
+                result[key] = None
+        return result