portacode 1.5.17.dev1__tar.gz → 1.5.17.dev3__tar.gz

{portacode-1.5.17.dev1 → portacode-1.5.17.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.5.17.dev1
+Version: 1.5.17.dev3
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian

{portacode-1.5.17.dev1 → portacode-1.5.17.dev3}/portacode/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.17.dev1'
-__version_tuple__ = version_tuple = (1, 5, 17, 'dev1')
+__version__ = version = '1.5.17.dev3'
+__version_tuple__ = version_tuple = (1, 5, 17, 'dev3')
 
 __commit_id__ = commit_id = None

{portacode-1.5.17.dev1 → portacode-1.5.17.dev3}/portacode/codex_prepare.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import logging
 import os
 import platform
 import re
@@ -17,6 +18,8 @@ from typing import Callable, Dict, Iterable, Mapping, MutableMapping, Optional
 
 from .codex_loopback_proxy import CODEX_LOOPBACK_HOST, CODEX_LOOPBACK_PORT
 
+LOGGER = logging.getLogger(__name__)
+
 # Do not pin `model` here — let the installed Codex CLI default apply, and let
 # the Portacode chat UI override via thread/start when the device supports it.
 CODEX_CONFIG = '''model_provider = "portacode_proxy"
@@ -24,11 +27,17 @@ approval_policy = "never"
 sandbox_mode = "danger-full-access"
 cli_auth_credentials_store = "file"
 
+# Force all model traffic through the local Portacode device proxy.
+# Newer Codex builds prefer WebSockets to api.openai.com; that bypasses our
+# proxy and treats OPENAI_API_KEY=portacode-local as a real OpenAI key (401).
+openai_base_url = "http://127.0.0.1:61789/v1"
+
 [model_providers.portacode_proxy]
 name = "Portacode Device Proxy"
 base_url = "http://127.0.0.1:61789/v1"
 wire_api = "responses"
 env_key = "OPENAI_API_KEY"
+supports_websockets = false
 '''
 
 LOCAL_SENTINEL = "portacode-local"
@@ -145,14 +154,72 @@ def _install_codex() -> None:
         raise CodexPreparationError("Codex CLI installation completed but codex is not on PATH.")
 
 
-def _write_config() -> Path:
-    config_path = Path.home() / ".codex" / "config.toml"
-    config_path.parent.mkdir(parents=True, exist_ok=True)
-    config_path.write_text(CODEX_CONFIG, encoding="utf-8")
-    config_path.chmod(0o600)
+def _extract_project_trust_blocks(existing: str) -> str:
+    """Keep Codex ``[projects."..."] trust_level`` stanzas when rewriting config."""
+    blocks: list[str] = []
+    current: list[str] = []
+    in_projects = False
+    for line in existing.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("[") and stripped.endswith("]"):
+            if in_projects and current:
+                blocks.append("\n".join(current).rstrip())
+            current = []
+            in_projects = stripped.startswith("[projects.")
+            if in_projects:
+                current = [line]
+            continue
+        if in_projects:
+            current.append(line)
+    if in_projects and current:
+        blocks.append("\n".join(current).rstrip())
+    if not blocks:
+        return ""
+    return "\n\n" + "\n\n".join(blocks) + "\n"
+
+
+def write_codex_config(codex_home: Optional[Path] = None) -> Path:
+    """Write the managed Codex config into the shared CODEX_HOME.
+
+    Always refreshes the Portacode proxy provider so runtime-user homes
+    (e.g. ``/home/bishoy/.codex``) cannot keep a stale default that sends
+    traffic to ``api.openai.com`` with the local sentinel key.
+    Preserves existing ``[projects.*]`` trust entries.
+    """
+    home = Path(codex_home) if codex_home is not None else resolve_codex_home()
+    home.mkdir(parents=True, exist_ok=True)
+    config_path = home / "config.toml"
+    existing = ""
+    try:
+        if config_path.is_file():
+            existing = config_path.read_text(encoding="utf-8")
+    except OSError:
+        existing = ""
+    body = CODEX_CONFIG.rstrip() + "\n" + _extract_project_trust_blocks(existing)
+    config_path.write_text(body, encoding="utf-8")
+    try:
+        config_path.chmod(0o600)
+    except OSError:
+        pass
+    try:
+        from portacode.connection.handlers.runtime_user import (
+            chown_path_if_possible,
+            get_default_runtime_user,
+        )
+
+        owner = get_default_runtime_user()
+        chown_path_if_possible(home, owner)
+        chown_path_if_possible(config_path, owner)
+    except Exception:
+        pass
     return config_path
 
 
+def _write_config() -> Path:
+    """Backward-compatible alias used by ``prepare_codex``."""
+    return write_codex_config()
+
+
 def read_codex_env_file(path: Optional[Path] = None) -> Dict[str, str]:
     """Parse KEY=VALUE lines from the managed Codex env file."""
     path = path or CODEX_ENV_PATH
@@ -256,7 +323,6 @@ def _persist_codex_home_env(codex_home: Path) -> None:
 
 def ensure_codex_home() -> Path:
     """Create CODEX_HOME and seed it from /root/.codex sessions when needed."""
-    import pwd
     import shutil
 
     codex_home = resolve_codex_home()
@@ -293,18 +359,23 @@ def ensure_codex_home() -> Path:
                     shutil.copy2(src, dest)
                 except OSError:
                     pass
+        # Only chown newly created paths — full-tree chown on every spawn made
+        # Codex app-server initialize race the 10s handshake timeout.
         try:
-            from portacode.connection.handlers.runtime_user import get_default_runtime_user
-
-            user = get_default_runtime_user()
-            pw_entry = pwd.getpwnam(user)
-            for path in [codex_home, *codex_home.rglob("*")]:
-                try:
-                    os.chown(path, pw_entry.pw_uid, pw_entry.pw_gid)
-                except OSError:
-                    pass
+            from portacode.connection.handlers.runtime_user import (
+                chown_path_if_possible,
+                get_default_runtime_user,
+            )
+
+            owner = get_default_runtime_user()
+            chown_path_if_possible(codex_home, owner)
+            chown_path_if_possible(sessions_dir, owner)
         except Exception:
             pass
+    try:
+        write_codex_config(codex_home)
+    except Exception:
+        LOGGER.debug("Could not refresh managed Codex config.toml", exc_info=True)
     try:
         _persist_codex_home_env(codex_home)
     except Exception:

{portacode-1.5.17.dev1 → portacode-1.5.17.dev3}/portacode/connection/codex_app_server.py

@@ -191,13 +191,15 @@ class CodexAppServer:
         Uses `_request_on_running_proc` so we do not re-enter `start()` while
         `start()` already holds `_lock` (asyncio.Lock is not reentrant).
         """
+        # Backfill / first boot can exceed a few seconds after CODEX_HOME moves
+        # or session indexes are rebuilt.
         response = await self._request_on_running_proc(
             "initialize",
             {
                 "clientInfo": self.client_info,
                 "capabilities": {"streaming": True},
             },
-            timeout=10.0,
+            timeout=60.0,
         )
         LOGGER.info("Codex app-server initialized: %s", response.get("result", {}))
         # Required by current Codex app-server clients so post-init notifications

{portacode-1.5.17.dev1 → portacode-1.5.17.dev3}/portacode/connection/handlers/project_state/git_manager.py

@@ -752,186 +752,132 @@ class GitManager:
             return None
     
     
+    def _parse_porcelain_entries(self) -> list[tuple[str, str, str]]:
+        """Parse ``git status --porcelain -z`` into (xy, path, orig_path) tuples.
+
+        Avoids GitPython ``index.diff`` / ``git diff --raw -z``, which can raise
+        uncaught IndexError in GitPython's stdout pump thread on some repos.
+        """
+        try:
+            raw = self.repo.git.status(porcelain=True, z=True)
+        except Exception as exc:
+            logger.debug("git status --porcelain -z failed: %s", exc)
+            return []
+        if not raw:
+            return []
+        # git -z separates records with NUL; rename records are "XY\\0path\\0orig\\0"
+        # or for porcelain v1 renames: "R  new\\0old\\0" depending on version.
+        parts = raw.split("\0")
+        entries: list[tuple[str, str, str]] = []
+        i = 0
+        while i < len(parts):
+            record = parts[i]
+            if not record:
+                i += 1
+                continue
+            if len(record) < 3:
+                i += 1
+                continue
+            xy = record[:2]
+            path = record[3:]
+            orig = ""
+            # Rename/copy may place the other path in the next NUL field.
+            if xy[0] in {"R", "C"} and i + 1 < len(parts) and parts[i + 1]:
+                # Some git versions emit "XY score\\tnewpath" then old path next.
+                if "\t" in path:
+                    path = path.split("\t", 1)[-1]
+                orig = parts[i + 1]
+                i += 2
+            else:
+                i += 1
+            if path:
+                entries.append((xy, path, orig))
+        return entries
+
     def get_detailed_status(self) -> GitDetailedStatus:
-        """Get detailed Git status with file hashes using GitPython APIs."""
+        """Get detailed Git status with file hashes via porcelain (no index.diff)."""
         if not self.is_git_repo or not self.repo:
             return GitDetailedStatus()
-        
+
         try:
             detailed_status = GitDetailedStatus()
             detailed_status.head_commit_hash = self.get_head_commit_hash()
-            
-            # Get all changed files using GitPython's index diff
-            # Get staged changes (index vs HEAD)
-            # Handle case where repository has no commits (no HEAD)
-            try:
-                staged_files = self.repo.index.diff("HEAD")
-            except Exception as e:
-                logger.debug("🔍 [TRACE] No HEAD found (likely no commits), using staged-only detection: %s", e)
-                # When no HEAD exists, we need to get staged files differently
-                staged_file_names = []
-                try:
-                    staged_output = self.repo.git.diff('--cached', '--name-only')
-                    staged_file_names = staged_output.splitlines() if staged_output.strip() else []
-                except Exception:
-                    staged_file_names = []
-                logger.debug("🔍 [TRACE] Found %d staged files in no-HEAD repo: %s", len(staged_file_names), staged_file_names)
-                
-                # Create staged file changes manually for no-HEAD repos
-                for file_repo_path in staged_file_names:
-                    file_abs_path = os.path.join(self.project_path, file_repo_path)
-                    file_name = os.path.basename(file_repo_path)
-                    content_hash = self._compute_file_hash(file_abs_path) if os.path.exists(file_abs_path) else None
-                    
-                    # For staged files in no-HEAD repo, they are all "added" (new files)
-                    diff_details = None
-                    
-                    change = GitFileChange(
-                        file_repo_path=file_repo_path,
-                        file_name=file_name,
-                        file_abs_path=file_abs_path,
-                        change_type='added',
-                        content_hash=content_hash,
-                        is_staged=True,
-                        diff_details=diff_details
-                    )
-                    logger.debug("🔍 [TRACE] Created staged change for no-HEAD repo: %s (added)", file_name)
-                    detailed_status.staged_changes.append(change)
-                
-                # Skip the normal staged files loop since we handled it above
-                staged_files = []
-            # Get git status --porcelain for accurate change types (GitPython diff can be buggy)
-            try:
-                porcelain_status = self.repo.git.status(porcelain=True).strip()
-                porcelain_map = {}
-                if porcelain_status:
-                    for line in porcelain_status.split('\n'):
-                        if len(line) >= 3:
-                            index_status = line[0]
-                            file_path = line[3:]
-                            porcelain_map[file_path] = index_status
-            except Exception:
-                porcelain_map = {}
-            
-            for diff_item in staged_files:
-                file_repo_path = diff_item.a_path or diff_item.b_path
+
+            for xy, file_repo_path, _orig in self._parse_porcelain_entries():
+                index_status = xy[0] if xy else " "
+                work_status = xy[1] if len(xy) > 1 else " "
                 file_abs_path = os.path.join(self.project_path, file_repo_path)
                 file_name = os.path.basename(file_repo_path)
-                
-                # Determine change type - use porcelain status for accuracy, fall back to GitPython
-                porcelain_status = porcelain_map.get(file_repo_path, '')
-                if porcelain_status == 'A':
-                    change_type = 'untracked'
-                elif porcelain_status == 'M':
-                    change_type = 'modified'
-                elif porcelain_status == 'D':
-                    change_type = 'deleted'
-                else:
-                    # Fall back to GitPython detection
-                    if diff_item.deleted_file:
-                        change_type = 'deleted'
-                    elif diff_item.new_file:
-                        change_type = 'untracked'
-                    else:
-                        change_type = 'modified'
-                
-                # Set content hash and diff details based on change type
-                if change_type == 'deleted':
+
+                # Untracked
+                if index_status == "?" and work_status == "?":
+                    content_hash = (
+                        self._compute_file_hash(file_abs_path)
+                        if os.path.exists(file_abs_path)
+                        else None
+                    )
+                    detailed_status.untracked_files.append(
+                        GitFileChange(
+                            file_repo_path=file_repo_path,
+                            file_name=file_name,
+                            file_abs_path=file_abs_path,
+                            change_type="untracked",
+                            content_hash=content_hash,
+                            is_staged=False,
+                            diff_details=None,
+                        )
+                    )
+                    continue
+
+                # Staged (index column)
+                if index_status not in {" ", "?", "!"}:
+                    # Preserve prior UI mapping: staged "A" was labeled untracked.
+                    change_type = (
+                        "untracked"
+                        if index_status == "A"
+                        else self._get_change_type(index_status)
+                    )
                     content_hash = None
-                    diff_details = None  # No diff for deleted files
-                elif change_type == 'untracked':
-                    content_hash = self._compute_file_hash(file_abs_path) if os.path.exists(file_abs_path) else None
-                    # For new files, compare empty content vs current staged content
-                    diff_details = None
-                else:  # modified
-                    content_hash = self._compute_file_hash(file_abs_path) if os.path.exists(file_abs_path) else None
-                    # Compare HEAD content vs staged content
-                    diff_details = None
-                
-                change = GitFileChange(
-                    file_repo_path=file_repo_path,
-                    file_name=file_name,
-                    file_abs_path=file_abs_path,
-                    change_type=change_type,
-                    content_hash=content_hash,
-                    is_staged=True,
-                    diff_details=diff_details
-                )
-                logger.debug("Created staged change for: %s (%s)", file_name, change_type)
-                detailed_status.staged_changes.append(change)
-            
-            # Get unstaged changes (working tree vs index)
-            try:
-                unstaged_files = self.repo.index.diff(None)
-            except Exception as e:
-                logger.debug("🔍 [TRACE] Error getting unstaged files: %s", e)
-                unstaged_files = []
-            for diff_item in unstaged_files:
-                file_repo_path = diff_item.a_path or diff_item.b_path
-                file_abs_path = os.path.join(self.project_path, file_repo_path)
-                file_name = os.path.basename(file_repo_path)
-                
-                # Determine change type - stick to git's native types
-                if diff_item.deleted_file:
-                    change_type = 'deleted'
+                    if change_type != "deleted" and os.path.exists(file_abs_path):
+                        content_hash = self._compute_file_hash(file_abs_path)
+                    detailed_status.staged_changes.append(
+                        GitFileChange(
+                            file_repo_path=file_repo_path,
+                            file_name=file_name,
+                            file_abs_path=file_abs_path,
+                            change_type=change_type,
+                            content_hash=content_hash,
+                            is_staged=True,
+                            diff_details=None,
+                        )
+                    )
+
+                # Unstaged (worktree column)
+                if work_status not in {" ", "?", "!"}:
+                    change_type = self._get_change_type(work_status)
                     content_hash = None
-                    diff_details = None  # No diff for deleted files
-                elif diff_item.new_file:
-                    change_type = 'added'
-                    content_hash = self._compute_file_hash(file_abs_path) if os.path.exists(file_abs_path) else None
-                    # For new files, compare empty content vs current working content
-                    diff_details = None
-                else:
-                    change_type = 'modified'
-                    content_hash = self._compute_file_hash(file_abs_path) if os.path.exists(file_abs_path) else None
-                    # Compare staged/index content vs working content
-                    diff_details = None
-                
-                change = GitFileChange(
-                    file_repo_path=file_repo_path,
-                    file_name=file_name,
-                    file_abs_path=file_abs_path,
-                    change_type=change_type,
-                    content_hash=content_hash,
-                    is_staged=False,
-                    diff_details=diff_details
-                )
-                logger.debug("Created unstaged change for: %s (%s)", file_name, change_type)
-                detailed_status.unstaged_changes.append(change)
-            
-            # Get untracked files
-            try:
-                untracked_files = self.repo.untracked_files
-                logger.debug("🔍 [TRACE] Processing %d untracked files: %s", len(untracked_files), untracked_files)
-            except Exception as e:
-                logger.debug("🔍 [TRACE] Error getting untracked files: %s", e)
-                untracked_files = []
-            for file_repo_path in untracked_files:
-                file_abs_path = os.path.join(self.project_path, file_repo_path)
-                file_name = os.path.basename(file_repo_path)
-                content_hash = self._compute_file_hash(file_abs_path) if os.path.exists(file_abs_path) else None
-                
-                # For untracked files, compare empty content vs current file content
-                diff_details = None
-                
-                change = GitFileChange(
-                    file_repo_path=file_repo_path,
-                    file_name=file_name,
-                    file_abs_path=file_abs_path,
-                    change_type='untracked',
-                    content_hash=content_hash,
-                    is_staged=False,
-                    diff_details=diff_details
-                )
-                logger.debug("🔍 [TRACE] Created untracked change for: %s", file_name)
-                detailed_status.untracked_files.append(change)
-            
-            logger.debug("🔍 [TRACE] Returning detailed_status with %d staged, %d unstaged, %d untracked", 
-                        len(detailed_status.staged_changes), 
-                        len(detailed_status.unstaged_changes), 
-                        len(detailed_status.untracked_files))
+                    if change_type != "deleted" and os.path.exists(file_abs_path):
+                        content_hash = self._compute_file_hash(file_abs_path)
+                    detailed_status.unstaged_changes.append(
+                        GitFileChange(
+                            file_repo_path=file_repo_path,
+                            file_name=file_name,
+                            file_abs_path=file_abs_path,
+                            change_type=change_type,
+                            content_hash=content_hash,
+                            is_staged=False,
+                            diff_details=None,
+                        )
+                    )
+
+            logger.debug(
+                "Returning detailed_status with %d staged, %d unstaged, %d untracked",
+                len(detailed_status.staged_changes),
+                len(detailed_status.unstaged_changes),
+                len(detailed_status.untracked_files),
+            )
             return detailed_status
-            
+
         except Exception as e:
             logger.error("Error getting detailed Git status: %s", e)
             return GitDetailedStatus()
@@ -1342,18 +1288,22 @@ class GitManager:
             except Exception:
                 has_head = False
             
-            if not has_head:
-                # For the first commit, check if anything is staged
+            # Prefer porcelain / diff --cached over index.diff (GitPython pump-thread bugs).
+            try:
+                staged_output = self.repo.git.diff("--cached", "--name-only")
+                has_staged = bool(staged_output.strip())
+            except Exception:
+                has_staged = False
+            if not has_staged and not has_head:
+                # First commit with only "git add" of new files still shows in status.
                 try:
-                    staged_output = self.repo.git.diff('--cached', '--name-only')
-                    has_staged = bool(staged_output.strip())
+                    has_staged = any(
+                        xy[0] not in {" ", "?", "!"}
+                        for xy, _path, _orig in self._parse_porcelain_entries()
+                    )
                 except Exception:
                     has_staged = False
-            else:
-                # Check if there are staged changes to commit
-                staged_changes = self.repo.index.diff("HEAD")
-                has_staged = len(staged_changes) > 0
-            
+
             if not has_staged:
                 raise RuntimeError("No staged changes to commit")
             

{portacode-1.5.17.dev1 → portacode-1.5.17.dev3}/portacode/connection/handlers/runtime_user.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 import pwd
 import shlex
+import shutil
 import stat
 from pathlib import Path
 from typing import Iterable, List, Optional, Sequence
@@ -69,22 +70,23 @@ def wrap_argv_for_user(
     """Wrap argv to run as ``user`` when the agent is root.
 
     ``login=True`` (default) matches terminal/git helpers with ``sudo -i``.
-    Long-lived daemons (e.g. Codex app-server) should pass ``login=False`` and
-    an explicit ``preserve_env_names`` list so managed env vars survive.
+    Long-lived daemons (e.g. Codex app-server) must pass ``login=False`` so we
+    use ``runuser``/``setpriv`` instead of ``sudo`` — many hosts enable
+    ``Defaults use_pty``, which breaks JSON-RPC over piped stdio.
     """
     argv_list = list(argv)
     if not should_switch_user(user):
         return argv_list
 
+    if not login:
+        return _wrap_daemon_argv_for_user(argv_list, user, cwd=cwd)
+
     preserved = [
         str(name or "").strip()
         for name in (preserve_env_names or [])
         if str(name or "").strip()
     ]
-    sudo_prefix = ["sudo", "-H"]
-    if login:
-        sudo_prefix.append("-i")
-    sudo_prefix.extend(["-u", user])
+    sudo_prefix = ["sudo", "-H", "-i", "-u", user]
     if preserved:
         sudo_prefix.append(f"--preserve-env={','.join(preserved)}")
     sudo_prefix.append("--")
@@ -100,6 +102,49 @@ def wrap_argv_for_user(
     return [*sudo_prefix, shell_path, "-lc", command]
 
 
+def _wrap_daemon_argv_for_user(
+    argv_list: List[str],
+    user: str,
+    *,
+    cwd: Optional[str] = None,
+) -> List[str]:
+    """Run a long-lived subprocess as ``user`` without allocating a PTY."""
+    if cwd:
+        shell_path = _resolve_shell_for_wrapped_argv(user, argv_list[0] if argv_list else "/bin/sh")
+        exec_command = " ".join(shlex.quote(arg) for arg in argv_list)
+        command = f"cd {shlex.quote(cwd)} && exec {exec_command}"
+        inner = [shell_path, "-lc", command]
+    else:
+        inner = list(argv_list)
+
+    runuser = shutil.which("runuser")
+    if runuser:
+        # --preserve-environment keeps OPENAI_API_KEY / CODEX_HOME from the
+        # parent env= mapping passed to create_subprocess_exec.
+        return [runuser, "-u", user, "--preserve-environment", "--", *inner]
+
+    setpriv = shutil.which("setpriv")
+    if setpriv:
+        try:
+            pw_entry = pwd.getpwnam(user)
+        except KeyError:
+            pw_entry = None
+        if pw_entry is not None:
+            return [
+                setpriv,
+                f"--reuid={pw_entry.pw_uid}",
+                f"--regid={pw_entry.pw_gid}",
+                "--init-groups",
+                "--",
+                *inner,
+            ]
+
+    # Last resort: sudo without login shell. Prefer -n (non-interactive).
+    # Hosts with Defaults use_pty may still break stdio — callers should prefer
+    # runuser on Linux agents.
+    return ["sudo", "-n", "-H", "-u", user, "--", *inner]
+
+
 def ensure_parent_dirs(path: str | Path, owner_user: Optional[str] = None) -> None:
     target = Path(path).parent
     missing: List[Path] = []

{portacode-1.5.17.dev1 → portacode-1.5.17.dev3}/portacode/connection/handlers/test_runtime_user.py

@@ -75,8 +75,9 @@ class RuntimeUserTests(TestCase):
         self.assertEqual(wrapped[5:8], ["--", "/bin/bash", "-lc"])
         self.assertIn("cd /home/meena/.openclaw && exec /bin/bash --login", wrapped[8])
 
+    @patch("portacode.connection.handlers.runtime_user.shutil.which", side_effect=lambda name: "/usr/sbin/runuser" if name == "runuser" else None)
     @patch("portacode.connection.handlers.runtime_user.os.geteuid", return_value=0)
-    def test_wrap_argv_for_user_non_login_preserves_env(self, _mock_euid):
+    def test_wrap_argv_for_user_non_login_uses_runuser(self, _mock_euid, _mock_which):
         wrapped = wrap_argv_for_user(
             ["codex", "app-server"],
             "meena",
@@ -84,10 +85,20 @@ class RuntimeUserTests(TestCase):
             login=False,
         )
         self.assertEqual(
-            wrapped[:6],
-            ["sudo", "-H", "-u", "meena", "--preserve-env=OPENAI_API_KEY,CODEX_HOME", "--"],
+            wrapped,
+            ["/usr/sbin/runuser", "-u", "meena", "--preserve-environment", "--", "codex", "app-server"],
         )
-        self.assertEqual(wrapped[6:], ["codex", "app-server"])
+
+    @patch("portacode.connection.handlers.runtime_user.shutil.which", return_value=None)
+    @patch("portacode.connection.handlers.runtime_user.os.geteuid", return_value=0)
+    def test_wrap_argv_for_user_non_login_falls_back_to_sudo_n(self, _mock_euid, _mock_which):
+        wrapped = wrap_argv_for_user(
+            ["codex", "app-server"],
+            "meena",
+            login=False,
+        )
+        self.assertEqual(wrapped[:5], ["sudo", "-n", "-H", "-u", "meena"])
+        self.assertEqual(wrapped[5:], ["--", "codex", "app-server"])
 
     @patch("portacode.connection.handlers.runtime_user.os.geteuid", return_value=0)
     @patch("portacode.connection.handlers.runtime_user.pwd.getpwnam")