@caupulican/pi-adaptative 0.81.42 → 0.84.1

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

@@ -1,13 +1,19 @@
-"""Entrypoint: read the JSON request, run the AST, emit merged output + control frame.
+"""Persistent coordinator: read JSON-line requests, run each AST, emit bounded terminal frames.
 
 The sole composition root — wires the real expander (`expand.expand_word`), the real
 command-substitution runner (`exec.run_command_substitution`), and the real builtin
 registry (`commands.REGISTRY`) into an `ExecContext`. See
 windows-shell-workpackages-2026-07-19.md §1.2/§1.3/§3.
+
+The process deliberately owns no shell state between requests. Node remains authoritative and
+passes the current cwd/environment on every request; the terminal frame carries the resulting
+delta back before the next serialized request is admitted. Keeping the interpreter/imports warm
+removes Python startup from every command without creating a second source of truth.
 """
 
 from __future__ import annotations
 
+import io
 import json
 import os
 import sys
@@ -22,11 +28,19 @@ from expand import ParamExpansionError
 from state import ShellState
 
 RECORD_SEPARATOR = b"\x1e"
+MAX_REQUEST_BYTES = 8 * 1024 * 1024
 
 
-def _read_request() -> dict:
-    raw = sys.stdin.buffer.read()
-    return json.loads(raw.decode("utf-8"))
+def _read_request() -> dict | None:
+    raw = sys.stdin.buffer.readline(MAX_REQUEST_BYTES + 1)
+    if not raw:
+        return None
+    if len(raw) > MAX_REQUEST_BYTES:
+        raise ValueError(f"request exceeds {MAX_REQUEST_BYTES} bytes")
+    decoded = json.loads(raw.decode("utf-8"))
+    if not isinstance(decoded, dict):
+        raise ValueError("request must be a JSON object")
+    return decoded
 
 
 class _OutputSink:
@@ -41,13 +55,21 @@ class _OutputSink:
         sys.stdout.buffer.flush()
 
 
-def _write_frame(exit_code: int, cwd: str, env_delta: dict, unsupported: dict | None) -> None:
+def _write_frame(
+    request_id: str | None,
+    exit_code: int,
+    cwd: str,
+    env_delta: dict,
+    unsupported: dict | None,
+) -> None:
     frame = {
         "exitCode": exit_code,
         "cwd": cwd,
         "envDelta": env_delta,
         "unsupported": unsupported,
     }
+    if request_id is not None:
+        frame["requestId"] = request_id
     # stderr is the control channel. Command stderr is explicitly merged into
     # the command-output sink by ExecContext, so this frame cannot collide with
     # arbitrary command bytes (including RECORD_SEPARATOR).
@@ -57,22 +79,61 @@ def _write_frame(exit_code: int, cwd: str, env_delta: dict, unsupported: dict |
     sys.stderr.buffer.flush()
 
 
-def main() -> int:
-    request = _read_request()
+def _write_terminal(
+    request_id: str | None,
+    exit_code: int,
+    cwd: str,
+    env_delta: dict,
+    unsupported: dict | None,
+) -> None:
+    sys.stdout.buffer.flush()
+    if request_id is not None:
+        # The frame and output travel over independent pipes. A request-specific barrier on the
+        # output pipe proves that every preceding command byte reached Node before it settles the
+        # control frame. Random request ids make collision with command bytes negligible.
+        sys.stdout.buffer.write(RECORD_SEPARATOR)
+        sys.stdout.buffer.write(request_id.encode("ascii"))
+        sys.stdout.buffer.write(RECORD_SEPARATOR)
+        sys.stdout.buffer.flush()
+    _write_frame(request_id, exit_code, cwd, env_delta, unsupported)
+
+
+def _request_id(request: dict) -> str | None:
+    request_id = request.get("requestId")
+    if request_id is None:
+        return None
+    if not isinstance(request_id, str) or len(request_id) != 16 or any(
+        char not in "0123456789abcdef" for char in request_id
+    ):
+        raise ValueError("requestId must be 16 lowercase hexadecimal characters")
+    return request_id
+
+
+def _run_request(request: dict) -> None:
+    request_id = _request_id(request)
     command: str = request["command"]
     cwd: str = request["cwd"]
     env: dict[str, str] = dict(request.get("env") or {})
     timeout_ms = request.get("timeoutMs")
+    powershell_path = request.get("powershellPath")
+    if not isinstance(powershell_path, str) or not powershell_path:
+        powershell_path = None
 
     original_env = dict(env)
 
     if not os.path.isdir(cwd):
         message = f"cwd does not exist: {cwd}"
         sys.stdout.buffer.write(message.encode("utf-8"))
-        _write_frame(2, cwd, {}, {"code": "unsupported", "construct": "cwd-missing", "message": message})
-        return 0
+        _write_terminal(
+            request_id,
+            2,
+            cwd,
+            {},
+            {"code": "unsupported", "construct": "cwd-missing", "message": message},
+        )
+        return
 
-    state = ShellState(cwd=cwd, env=env)
+    state = ShellState(cwd=cwd, env=env, powershell_path=powershell_path)
     output = _OutputSink()
 
     deadline = None
@@ -84,7 +145,9 @@ def main() -> int:
 
     ctx = ExecContext(
         state=state,
-        stdin=sys.stdin.buffer,
+        # Coordinator stdin is the request channel. Commands must observe the same immediate EOF
+        # they received from the former one-shot process, never consume a future protocol line.
+        stdin=io.BytesIO(),
         stdout=output,
         expand_word=expand_word,
         run_command_substitution=exec_module.run_command_substitution,
@@ -98,36 +161,56 @@ def main() -> int:
         ast = parser_module.parse(tokens)
         exit_code = exec_module.execute(ast, ctx)
     except ShellExit as exc:
-        _write_frame(exc.exit_code, state.cwd, state.delta(original_env), None)
-        return 0
+        _write_terminal(request_id, exc.exit_code, state.cwd, state.delta(original_env), None)
+        return
     except UnsupportedConstruct as exc:
         output.write(exc.message.encode("utf-8", errors="replace"))
-        _write_frame(
+        _write_terminal(
+            request_id,
             2,
             state.cwd,
             state.delta(original_env),
             {"code": exc.code, "construct": exc.construct, "message": exc.message},
         )
-        return 0
+        return
     except ParamExpansionError as exc:
         output.write(f"bash: {exc.name}: {exc.message}\n".encode("utf-8", errors="replace"))
-        _write_frame(1, state.cwd, state.delta(original_env), None)
-        return 0
+        _write_terminal(request_id, 1, state.cwd, state.delta(original_env), None)
+        return
     except (OSError, ValueError, UnicodeError) as exc:
         # Expected command/builtin failures must remain framed and must never
         # leak a Python traceback into the host shell protocol.
         output.write(f"shell: {exc}\n".encode("utf-8", errors="replace"))
-        _write_frame(1, state.cwd, state.delta(original_env), None)
-        return 0
+        _write_terminal(request_id, 1, state.cwd, state.delta(original_env), None)
+        return
     except Exception as exc:
         # Last-resort protocol boundary: preserve a bounded, actionable error
         # while keeping the control frame parseable.
         output.write(f"shell engine internal error: {type(exc).__name__}: {exc}\n".encode("utf-8", errors="replace"))
-        _write_frame(1, state.cwd, state.delta(original_env), None)
-        return 0
+        _write_terminal(request_id, 1, state.cwd, state.delta(original_env), None)
+        return
 
-    output.flush()
-    _write_frame(exit_code, state.cwd, state.delta(original_env), None)
+    _write_terminal(request_id, exit_code, state.cwd, state.delta(original_env), None)
+
+
+def main() -> int:
+    while True:
+        try:
+            request = _read_request()
+        except (json.JSONDecodeError, UnicodeError, ValueError) as exc:
+            # Without a trustworthy request id there is no safe frame to correlate. Terminate the
+            # coordinator; the Node owner rejects the active command and lazily starts a clean one.
+            sys.stderr.write(f"shell coordinator protocol error: {exc}\n")
+            sys.stderr.flush()
+            return 2
+        if request is None:
+            return 0
+        try:
+            _run_request(request)
+        except (KeyError, TypeError, ValueError, UnicodeError) as exc:
+            sys.stderr.write(f"shell coordinator invalid request: {exc}\n")
+            sys.stderr.flush()
+            return 2
     return 0
 
 

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

@@ -0,0 +1,10 @@
+"""Path resolution at the shell engine's explicit request-cwd boundary."""
+
+from __future__ import annotations
+
+import os
+
+
+def resolve_request_path(cwd: str, path: str) -> str:
+    candidate = path if os.path.isabs(path) else os.path.join(cwd, path)
+    return os.path.normpath(candidate)

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

@@ -1,6 +1,7 @@
 """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).
+WP-C owns this pure-stdlib process boundary; its contract is §3 of
+windows-shell-workpackages-2026-07-19.md.
 """
 
 from __future__ import annotations
@@ -55,11 +56,18 @@ def resolve_external(name: str, env: dict[str, str], cwd: str | None = None) ->
     return None
 
 
-def build_argv(resolved_path: str, argv: list[str]) -> list[str]:
-    """Wrap `.bat`/`.cmd` targets via `cmd /c`; direct-exec everything else."""
+def build_argv(
+    resolved_path: str,
+    argv: list[str],
+    powershell_path: str | None = None,
+) -> list[str]:
+    """Adapt Windows script targets; direct-exec native executables and POSIX files."""
     lower = resolved_path.lower()
     if lower.endswith(".bat") or lower.endswith(".cmd"):
         return ["cmd", "/c", resolved_path, *argv[1:]]
+    if lower.endswith(".ps1") and (powershell_path or os.name == "nt"):
+        host = powershell_path or "powershell.exe"
+        return [host, "-NoLogo", "-NoProfile", "-NonInteractive", "-File", resolved_path, *argv[1:]]
     return [resolved_path, *argv[1:]]
 
 
@@ -78,7 +86,7 @@ def spawn_external(
     resolved = resolve_external(argv[0], state.env, state.cwd)
     if resolved is None:
         raise FileNotFoundError(argv[0])
-    full_argv = build_argv(resolved, argv)
+    full_argv = build_argv(resolved, argv, state.powershell_path)
     kwargs: dict = {}
     if os.name != "nt":
         kwargs["start_new_session"] = True

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

@@ -0,0 +1,22 @@
+"""Bounded shell-argument scans shared by builtins."""
+
+from __future__ import annotations
+
+def split_leading_short_options(
+    args: list[str], allowed_chars: str | None = None
+) -> tuple[list[str], list[str]]:
+    options: list[str] = []
+    index = 0
+    while index < len(args):
+        arg = args[index]
+        if arg == "--":
+            return options, args[index + 1 :]
+        is_short_option = arg.startswith("-") and arg != "-" and len(arg) > 1
+        if not is_short_option or (
+            allowed_chars is not None
+            and any(char not in allowed_chars for char in arg[1:])
+        ):
+            break
+        options.append(arg)
+        index += 1
+    return options, args[index:]

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

@@ -1,6 +1,7 @@
 """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).
+This pure-stdlib WP-C state owner implements the environment contract documented in
+windows-shell-workpackages-2026-07-19.md §3.
 """
 
 from __future__ import annotations
@@ -65,6 +66,7 @@ class ShellState:
     cwd: str
     env: ShellEnvironment = field(default_factory=ShellEnvironment)
     last_exit_code: int = 0
+    powershell_path: str | None = None
 
     def __post_init__(self) -> None:
         if not isinstance(self.env, ShellEnvironment):
@@ -72,7 +74,12 @@ class ShellState:
 
     def copy(self) -> "ShellState":
         """Return an independent copy (used for subshell isolation)."""
-        return ShellState(cwd=self.cwd, env=self.env.copy(), last_exit_code=self.last_exit_code)
+        return ShellState(
+            cwd=self.cwd,
+            env=self.env.copy(),
+            last_exit_code=self.last_exit_code,
+            powershell_path=self.powershell_path,
+        )
 
     def chdir(self, path: str) -> None:
         """Validate `path` exists and is a directory, then update cwd + OLDPWD."""