@pushpalsdev/cli 1.0.46 → 1.0.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushpalsdev/cli",
-  "version": "1.0.46",
+  "version": "1.0.47",
   "description": "PushPals terminal CLI for LocalBuddy -> RemoteBuddy orchestration",
   "license": "MIT",
   "repository": {

package/runtime/sandbox/apps/workerpals/src/backends/openai_codex/openai_codex_executor.py

@@ -62,7 +62,6 @@ _CODEX_WORKAROUND_PATTERNS = (
     ),
     re.compile(r"\bwithout requiring\b.{0,120}\bcodex\b", re.IGNORECASE),
     re.compile(r"\bavoid(?:ing)?\b.{0,120}\bcodex\b.{0,120}\bcall", re.IGNORECASE),
-    re.compile(r"\b(fell back|fallback|worked around|workaround|bypass(?:ed)?|switched to)\b.{0,120}\bcodex\b", re.IGNORECASE),
 )
 _CODEX_WORKAROUND_NEGATION_HINTS = (
     "do not",
@@ -75,6 +74,15 @@ _CODEX_WORKAROUND_NEGATION_HINTS = (
     "explicit failure",
     "codex cli is required infrastructure",
 )
+_REJECTED_EXEC_COMMAND_PATTERN = re.compile(r"exec_command failed for `([^`]+)`", re.IGNORECASE)
+_DISALLOWED_SHELL_WRAPPER_PREFIXES = (
+    "/bin/bash -lc ",
+    "bash -lc ",
+    "sh -lc ",
+    "cmd /c ",
+    "powershell -command ",
+    "pwsh -command ",
+)
 
 _VALID_APPROVAL_POLICIES = {"untrusted", "on-failure", "on-request", "never"}
 _VALID_SANDBOX_POLICIES = {"read-only", "workspace-write", "danger-full-access"}
@@ -942,6 +950,37 @@ def _detect_codex_workaround_signal(*texts: str) -> Optional[str]:
     return None
 
 
+def _normalize_command_text(command: str) -> str:
+    return re.sub(r"\s+", " ", str(command or "")).strip()
+
+
+def _is_disallowed_shell_wrapper_command(command: str) -> bool:
+    normalized = _normalize_command_text(command).lower()
+    return any(normalized.startswith(prefix) for prefix in _DISALLOWED_SHELL_WRAPPER_PREFIXES)
+
+
+def _extract_rejected_exec_command(text: str) -> str:
+    match = _REJECTED_EXEC_COMMAND_PATTERN.search(str(text or ""))
+    if not match:
+        return ""
+    return _normalize_command_text(match.group(1))
+
+
+def _collect_disallowed_shell_wrapper_rejections(*texts: str) -> List[str]:
+    rejected: List[str] = []
+    seen: set[str] = set()
+    for text in texts:
+        command = _extract_rejected_exec_command(str(text or ""))
+        if not command or not _is_disallowed_shell_wrapper_command(command):
+            continue
+        lowered = command.lower()
+        if lowered in seen:
+            continue
+        seen.add(lowered)
+        rejected.append(command)
+    return rejected
+
+
 def _read_text_if_exists(path: Path) -> str:
     try:
         if not path.exists():
@@ -1166,6 +1205,7 @@ def _run_codex_task(
         stdout_trace_state = _empty_codex_trace()
         trace_lock = threading.Lock()
         last_activity_at = {"ts": started_at}
+        wrapper_rejection_state: Dict[str, Any] = {"count": 0, "commands": []}
 
         def _drain_stdout() -> None:
             stream = proc.stdout
@@ -1199,6 +1239,21 @@ def _run_codex_task(
                     if chunk == "":
                         break
                     stderr_chunks.append(chunk)
+                    rejected_commands = _collect_disallowed_shell_wrapper_rejections(chunk)
+                    if rejected_commands:
+                        with trace_lock:
+                            wrapper_rejection_state["count"] = to_int(
+                                wrapper_rejection_state.get("count"), 0
+                            ) + len(rejected_commands)
+                            tracked = wrapper_rejection_state.get("commands")
+                            if not isinstance(tracked, list):
+                                tracked = []
+                            for command in rejected_commands:
+                                lowered = command.lower()
+                                if any(str(item).lower() == lowered for item in tracked):
+                                    continue
+                                tracked.append(command)
+                            wrapper_rejection_state["commands"] = tracked[:6]
             except Exception:
                 pass
             finally:
@@ -1226,6 +1281,7 @@ def _run_codex_task(
         )
         next_progress_at = started_at + float(progress_interval_s)
         timed_out = False
+        command_policy_rejection_loop = False
 
         while proc.poll() is None:
             now = time.monotonic()
@@ -1234,6 +1290,13 @@ def _run_codex_task(
                 _terminate_active_child()
                 break
 
+            with trace_lock:
+                wrapper_rejections = to_int(wrapper_rejection_state.get("count"), 0)
+            if wrapper_rejections >= 3:
+                command_policy_rejection_loop = True
+                _terminate_active_child()
+                break
+
             if now >= next_progress_at:
                 elapsed = int(max(0.0, now - started_at))
                 with trace_lock:
@@ -1279,6 +1342,18 @@ def _run_codex_task(
             part for part in (stdout, stderr, trace_excerpt) if str(part or "").strip()
         )
         usage = _usage_from_trace_or_estimate(stdout_trace, prompt, usage_output_text, model=model)
+        rejected_shell_wrappers = _collect_disallowed_shell_wrapper_rejections(stdout, stderr)
+        with trace_lock:
+            tracked = wrapper_rejection_state.get("commands")
+            if isinstance(tracked, list):
+                for command in tracked:
+                    text = _normalize_command_text(str(command))
+                    if not text:
+                        continue
+                    lowered = text.lower()
+                    if any(entry.lower() == lowered for entry in rejected_shell_wrappers):
+                        continue
+                    rejected_shell_wrappers.append(text)
 
         if timed_out:
             detail = (
@@ -1300,6 +1375,30 @@ def _run_codex_task(
         last_message = _read_text_if_exists(last_message_path)
         log_git_status(repo, log)
 
+        if command_policy_rejection_loop:
+            command_lines = (
+                "\n".join(f"- {command}" for command in rejected_shell_wrappers[:6])
+                if rejected_shell_wrappers
+                else "- (no command details captured)"
+            )
+            detail = (
+                "Codex repeatedly attempted disallowed shell-wrapper commands that the command "
+                "router rejected. Switch to direct commands only and avoid wrapper retries.\n"
+                f"Rejected commands:\n{command_lines}"
+            )
+            if last_message:
+                detail = f"{detail}\nLast assistant message:\n{last_message}"
+            if trace_excerpt:
+                detail = f"{detail}\n{trace_excerpt}"
+            return {
+                "ok": False,
+                "summary": "openai_codex command policy rejection loop",
+                "stdout": _truncate(stdout),
+                "stderr": _truncate(detail),
+                "exitCode": 6,
+                "usage": usage,
+            }
+
         if _INTERRUPTED_SIGNAL is not None:
             return {
                 "ok": False,

package/runtime/sandbox/apps/workerpals/src/backends/openai_codex/test_openai_codex_runtime_config.py

@@ -15,6 +15,7 @@ from openai_codex_executor import (
     OpenAICodexRuntimeConfig,
     _resolve_reasoning_effort,
     _build_instruction,
+    _collect_disallowed_shell_wrapper_rejections,
     _detect_codex_workaround_signal,
     _extract_usage_counts,
     _load_prompt_template,
@@ -163,6 +164,12 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         )
         self.assertIsNone(signal)
 
+    def test_ignores_generic_workaround_language_without_unavailable_codex_context(self) -> None:
+        signal = _detect_codex_workaround_signal(
+            "This is a workaround case, so I am stopping here until the command router issue is fixed.",
+        )
+        self.assertIsNone(signal)
+
     def test_discovers_repo_root_for_prompt_loading(self) -> None:
         repo_root = _repo_root_for_prompt_loading()
         self.assertTrue((repo_root / "prompts").is_dir())
@@ -190,6 +197,14 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
             {"prompt_tokens": 120, "completion_tokens": 30, "total_tokens": 150},
         )
 
+    def test_collects_disallowed_shell_wrapper_rejections(self) -> None:
+        commands = _collect_disallowed_shell_wrapper_rejections(
+            "error=exec_command failed for `/bin/bash -lc pwd`: CreateProcess { message: \"Rejected\" }",
+            "error=exec_command failed for `sh -lc \"git diff\"`: Rejected",
+            "error=exec_command failed for `pwd`: Rejected",
+        )
+        self.assertEqual(commands, ["/bin/bash -lc pwd", 'sh -lc "git diff"'])
+
     def test_usage_falls_back_to_estimate_when_trace_has_no_usage(self) -> None:
         usage = _usage_from_trace_or_estimate({}, "abc" * 30, "done", model="gpt-5.4")
         self.assertTrue(usage["estimated"])