portacode 1.5.17.dev2__tar.gz → 1.5.17.dev4__tar.gz

{portacode-1.5.17.dev2 → portacode-1.5.17.dev4}/PKG-INFO

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

{portacode-1.5.17.dev2 → portacode-1.5.17.dev4}/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.dev2'
-__version_tuple__ = version_tuple = (1, 5, 17, 'dev2')
+__version__ = version = '1.5.17.dev4'
+__version_tuple__ = version_tuple = (1, 5, 17, 'dev4')
 
 __commit_id__ = commit_id = None

{portacode-1.5.17.dev2 → portacode-1.5.17.dev4}/portacode/codex_prepare.py

@@ -332,6 +332,7 @@ def ensure_codex_home() -> Path:
 
     root_codex = Path("/root/.codex")
     root_sessions = root_codex / "sessions"
+    seeded_paths: list[Path] = []
     if (
         hasattr(os, "geteuid")
         and os.geteuid() == 0
@@ -349,6 +350,8 @@ def ensure_codex_home() -> Path:
             dest.parent.mkdir(parents=True, exist_ok=True)
             try:
                 shutil.copy2(src, dest)
+                seeded_paths.append(dest)
+                seeded_paths.append(dest.parent)
             except OSError:
                 continue
         for name in ("config.toml", "auth.json"):
@@ -357,10 +360,11 @@ def ensure_codex_home() -> Path:
             if src.is_file() and not dest.exists():
                 try:
                     shutil.copy2(src, dest)
+                    seeded_paths.append(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.
+        # Chown seeded files (copy2 preserves root ownership). Avoid a full-tree
+        # walk on every spawn — that raced the initialize handshake.
         try:
             from portacode.connection.handlers.runtime_user import (
                 chown_path_if_possible,
@@ -370,6 +374,11 @@ def ensure_codex_home() -> Path:
             owner = get_default_runtime_user()
             chown_path_if_possible(codex_home, owner)
             chown_path_if_possible(sessions_dir, owner)
+            for path in seeded_paths:
+                chown_path_if_possible(path, owner)
+            for extra in (codex_home / "tmp", codex_home / ".tmp"):
+                if extra.exists():
+                    chown_path_if_possible(extra, owner)
         except Exception:
             pass
     try:

{portacode-1.5.17.dev2 → portacode-1.5.17.dev4}/portacode/connection/codex_app_server.py

@@ -128,19 +128,27 @@ class CodexAppServer:
             preserve_env_names=preserve,
             login=False,
         )
+        # Critical: the agent often runs with cwd=/root (mode 0700). Spawning a
+        # non-root Codex via runuser/setpriv while cwd is inaccessible makes
+        # Node/Codex hang or exit before answering initialize.
+        spawn_cwd = runtime_home if Path(runtime_home).is_dir() else None
         LOGGER.info(
-            "Spawning Codex app-server as %s: %s",
+            "Spawning Codex app-server as %s (cwd=%s): %s",
             runtime_user,
+            spawn_cwd or ".",
             " ".join(spawn_cmd),
         )
+        self._recent_stderr: List[str] = []
         try:
-            self._proc = await self._process_factory(
-                *spawn_cmd,
-                stdin=asyncio.subprocess.PIPE,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-                env=child_env,
-            )
+            spawn_kwargs: Dict[str, Any] = {
+                "stdin": asyncio.subprocess.PIPE,
+                "stdout": asyncio.subprocess.PIPE,
+                "stderr": asyncio.subprocess.PIPE,
+                "env": child_env,
+            }
+            if spawn_cwd:
+                spawn_kwargs["cwd"] = spawn_cwd
+            self._proc = await self._process_factory(*spawn_cmd, **spawn_kwargs)
         except Exception as exc:
             raise CodexAppServerError(f"Failed to spawn codex app-server: {exc}") from exc
 
@@ -241,7 +249,13 @@ class CodexAppServer:
             return await asyncio.wait_for(future, timeout=timeout)
         except asyncio.TimeoutError as exc:
             self._pending.pop(request_id, None)
-            raise CodexAppServerError(f"codex app-server request timed out: {method}") from exc
+            detail = f"codex app-server request timed out: {method}"
+            recent = getattr(self, "_recent_stderr", None) or []
+            if recent:
+                detail = f"{detail} (stderr: {' | '.join(recent[-5:])})"
+            if self._proc is not None and self._proc.returncode is not None:
+                detail = f"{detail} (process exited code {self._proc.returncode})"
+            raise CodexAppServerError(detail) from exc
 
     async def _write_notification_on_running_proc(
         self, method: str, params: Dict[str, Any]
@@ -305,7 +319,16 @@ class CodexAppServer:
                     break
                 text = line.decode("utf-8", errors="replace").rstrip()
                 if text:
-                    LOGGER.debug("codex app-server stderr: %s", text)
+                    # Keep a small ring for timeout errors; use WARNING so
+                    # initialize failures are visible at default journal levels.
+                    buf = getattr(self, "_recent_stderr", None)
+                    if buf is None:
+                        self._recent_stderr = []
+                        buf = self._recent_stderr
+                    buf.append(text)
+                    if len(buf) > 40:
+                        del buf[:-40]
+                    LOGGER.warning("codex app-server stderr: %s", text)
         except asyncio.CancelledError:
             raise
         except Exception:
@@ -350,6 +373,14 @@ class CodexAppServer:
         async with self._lock:
             if self._closed or self._proc is None:
                 return
+            # If initialize never completed, the caller still holding start()
+            # will surface the error — avoid a restart storm on bad cwd/env.
+            if not self._initialized.is_set():
+                LOGGER.warning(
+                    "Codex app-server process exited during startup (code %s)",
+                    self._proc.returncode,
+                )
+                return
             LOGGER.warning("Codex app-server process exited (code %s); restarting", self._proc.returncode)
             await self._kill_locked()
         try:

{portacode-1.5.17.dev2 → portacode-1.5.17.dev4}/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.dev2 → portacode-1.5.17.dev4}/portacode/tests/test_codex_app_server.py

@@ -119,19 +119,21 @@ async def test_spawn_injects_openai_api_key(tmp_path, monkeypatch):
     env_file.write_text("OPENAI_API_KEY=portacode-local\n", encoding="utf-8")
     monkeypatch.setattr("portacode.codex_prepare.CODEX_ENV_PATH", env_file)
     monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+    home = tmp_path / "home"
+    home.mkdir()
     monkeypatch.setattr(
         "portacode.connection.handlers.runtime_user.get_default_runtime_user",
         lambda message=None: "bishoy",
     )
     monkeypatch.setattr(
         "portacode.connection.handlers.runtime_user.get_runtime_user_home",
-        lambda message=None: str(tmp_path / "home"),
+        lambda message=None: str(home),
     )
     monkeypatch.setattr(
         "portacode.connection.handlers.runtime_user.should_switch_user",
         lambda user: True,
     )
-    monkeypatch.setattr("portacode.codex_prepare.ensure_codex_home", lambda: tmp_path / "home" / ".codex")
+    monkeypatch.setattr("portacode.codex_prepare.ensure_codex_home", lambda: home / ".codex")
 
     proc = FakeProcess([{"jsonrpc": "2.0", "id": 1, "result": {"protocolVersion": "v2"}}])
     bridge = CodexAppServer(_process_factory=_factory_for(proc))
@@ -139,9 +141,10 @@ async def test_spawn_injects_openai_api_key(tmp_path, monkeypatch):
 
     env = getattr(proc, "spawn_kwargs", {}).get("env") or {}
     assert env.get("OPENAI_API_KEY") == "portacode-local"
-    assert env.get("HOME") == str(tmp_path / "home")
+    assert env.get("HOME") == str(home)
     assert env.get("USER") == "bishoy"
-    assert env.get("CODEX_HOME") == str(tmp_path / "home" / ".codex")
+    assert env.get("CODEX_HOME") == str(home / ".codex")
+    assert getattr(proc, "spawn_kwargs", {}).get("cwd") == str(home)
     # factory receives argv as *args before stdout/stdin kwargs
     await bridge.stop()
 
@@ -150,6 +153,8 @@ async def test_spawn_injects_openai_api_key(tmp_path, monkeypatch):
 async def test_spawn_runs_as_runtime_user(tmp_path, monkeypatch):
     env_file = tmp_path / "codex.env"
     env_file.write_text("OPENAI_API_KEY=portacode-local\n", encoding="utf-8")
+    home = tmp_path / "home"
+    home.mkdir()
     monkeypatch.setattr("portacode.codex_prepare.CODEX_ENV_PATH", env_file)
     monkeypatch.setattr(
         "portacode.connection.handlers.runtime_user.get_default_runtime_user",
@@ -157,7 +162,7 @@ async def test_spawn_runs_as_runtime_user(tmp_path, monkeypatch):
     )
     monkeypatch.setattr(
         "portacode.connection.handlers.runtime_user.get_runtime_user_home",
-        lambda message=None: "/home/bishoy",
+        lambda message=None: str(home),
     )
     monkeypatch.setattr(
         "portacode.connection.handlers.runtime_user.should_switch_user",
@@ -172,12 +177,14 @@ async def test_spawn_runs_as_runtime_user(tmp_path, monkeypatch):
 
     monkeypatch.setattr("portacode.connection.handlers.runtime_user.shutil.which", _which)
     monkeypatch.setattr("portacode.connection.codex_app_server.shutil.which", _which)
-    monkeypatch.setattr("portacode.codex_prepare.ensure_codex_home", lambda: tmp_path / ".codex")
+    monkeypatch.setattr("portacode.codex_prepare.ensure_codex_home", lambda: home / ".codex")
 
     seen: list[tuple] = []
+    seen_kwargs: list[dict] = []
 
     async def factory(*args, **kwargs):
         seen.append(args)
+        seen_kwargs.append(kwargs)
         proc = FakeProcess([{"jsonrpc": "2.0", "id": 1, "result": {"protocolVersion": "v2"}}])
         proc.spawn_kwargs = kwargs
         return proc
@@ -187,6 +194,7 @@ async def test_spawn_runs_as_runtime_user(tmp_path, monkeypatch):
     assert seen
     assert seen[0][:5] == ("/usr/sbin/runuser", "-u", "bishoy", "--preserve-environment", "--")
     assert "codex" in seen[0]
+    assert seen_kwargs[0].get("cwd") == str(home)
     await bridge.stop()
 
 

{portacode-1.5.17.dev2 → portacode-1.5.17.dev4}/portacode.egg-info/PKG-INFO

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