portacode 1.5.6.dev1__tar.gz → 1.5.6.dev3__tar.gz

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

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

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

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.5.6.dev1'
-__version_tuple__ = version_tuple = (1, 5, 6, 'dev1')
+__version__ = version = '1.5.6.dev3'
+__version_tuple__ = version_tuple = (1, 5, 6, 'dev3')
 
 __commit_id__ = commit_id = None

portacode-1.5.6.dev3/portacode/connection/handlers/file_transfer_handlers.py

@@ -0,0 +1,206 @@
+"""Isolated handlers for websocket file upload and download transfers."""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import logging
+import os
+import pwd
+import stat
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from .base import AsyncHandler, SyncHandler
+from .chunked_content import ChunkAssembler, create_chunked_response
+from .project_state.manager import get_or_create_project_state_manager
+from .runtime_user import get_default_runtime_user
+
+logger = logging.getLogger(__name__)
+
+
+def _schedule_project_state_refresh(handler, changed_path: str) -> None:
+    try:
+        manager = get_or_create_project_state_manager(handler.context, handler.control_channel)
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            loop.create_task(manager.refresh_project_state_for_file_change(str(changed_path)))
+    except Exception as exc:
+        logger.warning("Failed to refresh project state after transfer for %s: %s", changed_path, exc)
+
+
+def _chown_path_if_possible(path: str | Path, user: Optional[str]) -> None:
+    if not user or os.name == "nt":
+        return
+    try:
+        pw_entry = pwd.getpwnam(user)
+        os.chown(path, pw_entry.pw_uid, pw_entry.pw_gid)
+    except Exception:
+        return
+
+
+def _restore_metadata(path: Path, original_stat: Optional[os.stat_result]) -> None:
+    if original_stat is None:
+        return
+    try:
+        os.chmod(path, stat.S_IMODE(original_stat.st_mode))
+    except OSError:
+        pass
+    try:
+        os.chown(path, original_stat.st_uid, original_stat.st_gid)
+    except OSError:
+        pass
+
+
+def _write_bytes_preserve_metadata(path: str | Path, content: bytes, *, create_user: Optional[str] = None) -> int:
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    existed = target.exists()
+    original_stat = target.stat() if existed else None
+
+    with open(target, "wb") as file_obj:
+        file_obj.write(content)
+
+    if existed:
+        _restore_metadata(target, original_stat)
+    else:
+        _chown_path_if_possible(target, create_user)
+
+    return len(content)
+
+
+class FileUploadHandler(SyncHandler):
+    """Upload a file to disk, optionally across multiple websocket chunks."""
+
+    def __init__(self, control_channel, context):
+        super().__init__(control_channel, context)
+        self._chunk_assembler = ChunkAssembler()
+
+    @property
+    def command_name(self) -> str:
+        return "file_upload"
+
+    def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        path = message.get("path")
+        file_name = message.get("file_name") or (Path(path).name if path else None)
+        mime_type = message.get("mime_type") or "application/octet-stream"
+        chunked = bool(message.get("chunked", False))
+
+        try:
+            self._chunk_assembler.cleanup_stale_transfers()
+            if not path:
+                raise ValueError("path parameter is required")
+
+            content_base64 = message.get("content_base64")
+            if chunked:
+                content_base64 = self._chunk_assembler.add_chunk(message, "content_base64")
+                if content_base64 is None:
+                    return {
+                        "event": "file_upload_response",
+                        "path": path,
+                        "file_name": file_name,
+                        "mime_type": mime_type,
+                        "transfer_id": message.get("transfer_id"),
+                        "chunked": True,
+                        "chunk_received": True,
+                        "success": True,
+                        "complete": False,
+                    }
+
+            if content_base64 is None:
+                raise ValueError("content_base64 parameter is required")
+
+            overwrite = bool(message.get("overwrite", False))
+            file_path = Path(path)
+            parent_dir = file_path.parent
+            if not parent_dir.exists():
+                raise ValueError(f"Parent directory does not exist: {parent_dir}")
+            if not parent_dir.is_dir():
+                raise ValueError(f"Parent path is not a directory: {parent_dir}")
+            if file_path.exists() and not overwrite:
+                raise ValueError(f"Target already exists: {file_path}")
+
+            try:
+                content_bytes = base64.b64decode(content_base64.encode("ascii"), validate=True)
+            except Exception as exc:
+                raise ValueError(f"Invalid base64 file content: {exc}") from exc
+
+            bytes_written = _write_bytes_preserve_metadata(
+                file_path,
+                content_bytes,
+                create_user=get_default_runtime_user(message),
+            )
+            _schedule_project_state_refresh(self, str(file_path))
+
+            return {
+                "event": "file_upload_response",
+                "path": str(file_path),
+                "file_name": file_name,
+                "mime_type": mime_type,
+                "bytes_written": bytes_written,
+                "file_size": len(content_bytes),
+                "chunked": chunked,
+                "success": True,
+                "complete": True,
+            }
+        except Exception as exc:
+            return {
+                "event": "file_upload_response",
+                "path": path,
+                "file_name": file_name,
+                "mime_type": mime_type,
+                "chunked": chunked,
+                "success": False,
+                "complete": True,
+                "error": str(exc),
+                "message": str(exc),
+            }
+
+
+class FileDownloadHandler(AsyncHandler):
+    """Read a file from disk and send it as base64, chunked when large."""
+
+    @property
+    def command_name(self) -> str:
+        return "file_download"
+
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        path = message.get("path")
+        try:
+            if not path:
+                raise ValueError("path parameter is required")
+
+            file_path = Path(path)
+            if not file_path.exists():
+                raise ValueError(f"File not found: {path}")
+            if not file_path.is_file():
+                raise ValueError(f"Path is not a file: {path}")
+
+            content_bytes = file_path.read_bytes()
+            content_base64 = base64.b64encode(content_bytes).decode("ascii")
+            base_response = {
+                "event": "file_download_response",
+                "path": str(file_path),
+                "file_name": file_path.name,
+                "mime_type": message.get("mime_type") or "application/octet-stream",
+                "file_size": len(content_bytes),
+                "success": True,
+            }
+            if "request_id" in message:
+                base_response["request_id"] = message["request_id"]
+
+            for response in create_chunked_response(base_response, "content_base64", content_base64):
+                await self.send_response(response, project_id=message.get("project_id"))
+            return None
+        except Exception as exc:
+            response = {
+                "event": "file_download_response",
+                "path": path,
+                "success": False,
+                "chunked": False,
+                "error": str(exc),
+                "message": str(exc),
+            }
+            if "request_id" in message:
+                response["request_id"] = message["request_id"]
+            return response

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

@@ -16,6 +16,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from .models import GitDetailedStatus, GitFileChange
+from ..runtime_user import get_default_runtime_user, wrap_argv_for_user
 
 logger = logging.getLogger(__name__)
 
@@ -138,6 +139,30 @@ class GitManager:
                     continue
         except Exception as e:
             logger.debug("Error tracking git processes: %s", e)
+
+    def _run_git_write(self, args: List[str]) -> subprocess.CompletedProcess:
+        """Run a mutating git command as the configured runtime user."""
+        runtime_user = get_default_runtime_user()
+        cwd = self.repo.working_tree_dir if self.repo and self.repo.working_tree_dir else self.project_path
+        argv = wrap_argv_for_user(["git", *args], runtime_user, cwd=cwd)
+        return subprocess.run(
+            argv,
+            cwd=cwd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+
+    def _remove_file_as_runtime_user(self, file_path: str) -> None:
+        runtime_user = get_default_runtime_user()
+        argv = wrap_argv_for_user(["rm", "-f", file_path], runtime_user, cwd=os.path.dirname(file_path) or None)
+        subprocess.run(
+            argv,
+            cwd=os.path.dirname(file_path) or None,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
     
     def reinitialize(self):
         """Reinitialize git repo detection (useful when .git directory is created after initialization)."""
@@ -992,10 +1017,10 @@ class GitManager:
             if self._is_submodule(file_path):
                 logger.info("Detected submodule, using git add command directly: %s", rel_path)
                 # For submodules, use git add directly to stage only the submodule reference
-                self.repo.git.add(rel_path)
+                self._run_git_write(["add", rel_path])
             else:
                 # Use git add -A on the specific file to handle deletions as well
-                self.repo.git.add('-A', '--', rel_path)
+                self._run_git_write(["add", "-A", "--", rel_path])
             
             logger.info("Successfully staged file: %s", rel_path)
             return True
@@ -1017,7 +1042,7 @@ class GitManager:
             if self._is_submodule(file_path):
                 logger.info("Detected submodule, using git restore for unstaging: %s", rel_path)
                 # For submodules, always use git restore --staged (works with submodules)
-                self.repo.git.restore('--staged', rel_path)
+                self._run_git_write(["restore", "--staged", rel_path])
             else:
                 # Check if repository has any commits (HEAD exists)
                 try:
@@ -1028,10 +1053,10 @@ class GitManager:
                 
                 if has_head:
                     # Reset the file from HEAD (unstage) - for repos with commits
-                    self.repo.git.restore('--staged', rel_path)
+                    self._run_git_write(["restore", "--staged", rel_path])
                 else:
                     # For repositories with no commits, use git rm --cached to unstage
-                    self.repo.git.rm('--cached', rel_path)
+                    self._run_git_write(["rm", "--cached", rel_path])
             
             logger.info("Successfully unstaged file: %s", rel_path)
             return True
@@ -1058,13 +1083,13 @@ class GitManager:
             
             if has_head:
                 # Restore both index and working tree from HEAD
-                self.repo.git.restore('--staged', '--worktree', '--', rel_path)
+                self._run_git_write(["restore", "--staged", "--worktree", "--", rel_path])
                 logger.info("Successfully reverted file: %s", rel_path)
             else:
                 # For repositories with no commits, we can't revert to HEAD
                 # Instead, just remove the file to "revert" it to non-existence
                 if os.path.exists(file_path):
-                    os.remove(file_path)
+                    self._remove_file_as_runtime_user(file_path)
                     logger.info("Successfully removed file (no HEAD to revert to): %s", rel_path)
                 else:
                     logger.info("File already does not exist (no HEAD to revert to): %s", rel_path)
@@ -1100,12 +1125,12 @@ class GitManager:
             if submodule_paths:
                 logger.info("Staging submodules using git add directly: %s", submodule_paths)
                 for submodule_path in submodule_paths:
-                    self.repo.git.add(submodule_path)
+                    self._run_git_write(["add", submodule_path])
             
             # Stage regular files using git add -A to capture deletions
             if rel_paths:
                 logger.info("Staging regular files: %s", rel_paths)
-                self.repo.git.add('-A', '--', *rel_paths)
+                self._run_git_write(["add", "-A", "--", *rel_paths])
             
             logger.info("Successfully staged %d files (%d submodules, %d regular)", 
                        len(file_paths), len(submodule_paths), len(rel_paths))
@@ -1149,11 +1174,11 @@ class GitManager:
             if has_head:
                 # Use git restore --staged for all files (works for both regular files and submodules)
                 if all_rel_paths:
-                    self.repo.git.restore('--staged', *all_rel_paths)
+                    self._run_git_write(["restore", "--staged", *all_rel_paths])
             else:
                 # For repositories with no commits, use git rm --cached
                 if all_rel_paths:
-                    self.repo.git.rm('--cached', *all_rel_paths)
+                    self._run_git_write(["rm", "--cached", *all_rel_paths])
             
             logger.info("Successfully unstaged %d files (%d submodules, %d regular)", 
                        len(file_paths), len(submodule_paths), len(rel_paths))
@@ -1190,14 +1215,14 @@ class GitManager:
                         regular_files.append(rel_paths[i])
                 
                 if regular_files:
-                    self.repo.git.restore('--staged', '--worktree', '--', *regular_files)
+                    self._run_git_write(["restore", "--staged", "--worktree", "--", *regular_files])
                     logger.info("Successfully reverted %d files", len(regular_files))
             else:
                 # For repositories with no commits, remove files to "revert" them
                 removed_count = 0
                 for file_path in file_paths:
                     if not self._is_submodule(file_path) and os.path.exists(file_path):
-                        os.remove(file_path)
+                        self._remove_file_as_runtime_user(file_path)
                         removed_count += 1
                 logger.info("Successfully removed %d files (no HEAD to revert to)", removed_count)
             
@@ -1214,7 +1239,7 @@ class GitManager:
         
         try:
             # Use git add . to stage everything - this is the most efficient way
-            self.repo.git.add('.')
+            self._run_git_write(["add", "."])
             logger.info("Successfully staged all changes using 'git add .'")
             return True
             
@@ -1237,10 +1262,10 @@ class GitManager:
             
             if has_head:
                 # Use git restore --staged . to unstage everything
-                self.repo.git.restore('--staged', '.')
+                self._run_git_write(["restore", "--staged", "."])
             else:
                 # For repositories with no commits, remove everything from index
-                self.repo.git.rm('--cached', '-r', '.')
+                self._run_git_write(["rm", "--cached", "-r", "."])
             
             logger.info("Successfully unstaged all changes")
             return True
@@ -1264,7 +1289,7 @@ class GitManager:
             
             if has_head:
                 # Use git restore . to revert all working directory changes
-                self.repo.git.restore('.')
+                self._run_git_write(["restore", "."])
                 logger.info("Successfully reverted all working directory changes")
             else:
                 logger.warning("Cannot revert changes in repository with no commits")
@@ -1308,7 +1333,8 @@ class GitManager:
                 raise RuntimeError("No staged changes to commit")
             
             # Perform the commit
-            commit = self.repo.index.commit(message.strip())
+            self._run_git_write(["commit", "-m", message.strip()])
+            commit = self.repo.head.commit
             logger.info("Successfully committed changes with hash: %s", commit.hexsha)
             logger.info("Commit message: %s", message.strip())
             

{portacode-1.5.6.dev1 → portacode-1.5.6.dev3}/portacode/connection/terminal.py

@@ -74,6 +74,7 @@ from .handlers.project_aware_file_handlers import (
     ProjectAwareFileCreateHandler,
     ProjectAwareFolderCreateHandler,
 )
+from .handlers.file_transfer_handlers import FileUploadHandler, FileDownloadHandler
 from .handlers.session import SessionManager
 from .webmin_proxy_config import apply_turnkey_webmin_proxy_config
 from portacode.tunneling.privileged import read_text, run, write_text
@@ -512,6 +513,8 @@ class TerminalManager:
         self._command_registry.register(ProjectAwareFileCreateHandler)  # Use project-aware version
         self._command_registry.register(ProjectAwareFolderCreateHandler)  # Use project-aware version
         self._command_registry.register(FileRenameHandler)
+        self._command_registry.register(FileUploadHandler)
+        self._command_registry.register(FileDownloadHandler)
         self._command_registry.register(FileSearchHandler)
         self._command_registry.register(ContentRequestHandler)
         self._command_registry.register(FileApplyDiffHandler)

{portacode-1.5.6.dev1 → portacode-1.5.6.dev3}/portacode.egg-info/PKG-INFO

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

{portacode-1.5.6.dev1 → portacode-1.5.6.dev3}/portacode.egg-info/SOURCES.txt

@@ -310,6 +310,7 @@ portacode/connection/handlers/cloudflare_forwarding.py
 portacode/connection/handlers/cloudflare_tunnel.py
 portacode/connection/handlers/diff_handlers.py
 portacode/connection/handlers/file_handlers.py
+portacode/connection/handlers/file_transfer_handlers.py
 portacode/connection/handlers/project_aware_file_handlers.py
 portacode/connection/handlers/project_state_handlers.py
 portacode/connection/handlers/proxmox_infra.py