portacode 1.5.21.dev0__tar.gz → 1.5.21.dev2__tar.gz

{portacode-1.5.21.dev0 → portacode-1.5.21.dev2}/PKG-INFO

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

{portacode-1.5.21.dev0 → portacode-1.5.21.dev2}/portacode/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.21.dev0'
-__version_tuple__ = version_tuple = (1, 5, 21, 'dev0')
+__version__ = version = '1.5.21.dev2'
+__version_tuple__ = version_tuple = (1, 5, 21, 'dev2')
 
 __commit_id__ = commit_id = None

{portacode-1.5.21.dev0 → portacode-1.5.21.dev2}/portacode/codex_loopback_proxy.py

@@ -36,7 +36,7 @@ DEFAULT_GATEWAY_URL = "https://codexapi.portacode.com/v1"
 MAX_REQUEST_BYTES = 32 * 1024 * 1024
 MAX_FORWARD_REQUEST_BYTES = 10 * 1024 * 1024
 MAX_TOOL_OUTPUT_BYTES = 64 * 1024
-ALLOWED_PATHS = {"/health", "/v1/models", "/v1/responses"}
+ALLOWED_PATHS = {"/health", "/v1/models", "/v1/responses", "/v1/responses/compact"}
 MAX_CONCURRENT_UPSTREAM = 8
 
 # Streaming read can idle between SSE chunks; connect/write stay bounded.
@@ -117,9 +117,51 @@ def sanitize_responses_request(body: bytes) -> tuple[bytes, int, int]:
                         part["text"] = cropped
                         changed += 1
                         omitted_total += omitted
-    if not changed:
-        return body, 0, 0
-    return json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8"), changed, omitted_total
+    encoded = (
+        json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+        if changed
+        else body
+    )
+    if len(encoded) <= MAX_FORWARD_REQUEST_BYTES:
+        return encoded, changed, omitted_total
+
+    # Image-producing tools return screenshots as inline data URLs. A long
+    # session can therefore be under the model token limit while its JSON body
+    # is many megabytes too large to forward. Remove the oldest inline images
+    # first, retaining newer screenshots whenever that is sufficient. Text
+    # alongside each screenshot remains available to compaction/inference.
+    image_parts: list[dict] = []
+    for item in payload["input"]:
+        if not isinstance(item, dict) or item.get("type") not in _TOOL_OUTPUT_TYPES:
+            continue
+        value = item.get("output") or item.get("content")
+        if not isinstance(value, list):
+            continue
+        for part in value:
+            if (
+                isinstance(part, dict)
+                and part.get("type") in {"input_image", "image_url"}
+                and isinstance(part.get("image_url"), str)
+                and part["image_url"].startswith("data:image/")
+            ):
+                image_parts.append(part)
+
+    for part in image_parts:
+        if len(encoded) <= MAX_FORWARD_REQUEST_BYTES:
+            break
+        original_bytes = len(part["image_url"].encode("utf-8"))
+        part.clear()
+        part.update(
+            {
+                "type": "input_text",
+                "text": "[Portacode omitted an older inline tool screenshot to keep the request within the forwarding limit.]",
+            }
+        )
+        changed += 1
+        omitted_total += original_bytes
+        encoded = json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+
+    return encoded, changed, omitted_total
 
 FORWARD_RESPONSE_HEADERS = frozenset(
     {
@@ -327,7 +369,7 @@ class CodexLoopbackProxy:
             if method == "GET" and path != "/v1/models":
                 await self._write_error(writer, 405, "Method not allowed")
                 return
-            if method == "POST" and path != "/v1/responses":
+            if method == "POST" and path not in {"/v1/responses", "/v1/responses/compact"}:
                 await self._write_error(writer, 405, "Method not allowed")
                 return
             await self._forward(writer, method, path, headers, body, req_id=req_id)
@@ -451,7 +493,7 @@ class CodexLoopbackProxy:
         *,
         req_id: str,
     ) -> None:
-        if method == "POST" and path == "/v1/responses" and body:
+        if method == "POST" and path in {"/v1/responses", "/v1/responses/compact"} and body:
             body, cropped_fields, omitted_bytes = sanitize_responses_request(body)
             if cropped_fields:
                 LOGGER.warning(

{portacode-1.5.21.dev0 → portacode-1.5.21.dev2}/portacode/connection/handlers/WEBSOCKET_PROTOCOL.md

@@ -830,10 +830,12 @@ its SHA-256 hash and binds it to one `transfer_id`, role, and path. Possession o
 a transfer ID alone grants no access.
 
 Folders are packaged once as an uncompressed PAX tar archive so subsequent
-chunk reads remain byte-for-byte stable. Destination extraction rejects path
-traversal, escaping links, and special device files. Modes, timestamps, numeric
-ownership, symlinks, and hard links are retained when the destination operating
-system and process privileges allow it.
+chunk reads remain byte-for-byte stable. Source preparation and destination
+extraction reject symbolic/hard links, special device files, path traversal,
+and archives with more than the configured entry limit. Modes, timestamps, and
+numeric ownership are retained when the destination operating system and
+process privileges allow it. Links are deliberately rejected because chained
+archive links cannot be extracted safely by legacy Python runtimes.
 
 ### `transfer_prepare`
 
@@ -851,7 +853,10 @@ Destination preparation additionally requires the source's `payload_size`,
 `entry_count`, `metadata`, and `archive_format`. It refuses the operation when
 free space cannot accommodate the incoming payload, simultaneous extraction,
 destination filesystem entry overhead, and a safety reserve. `overwrite`
-defaults to false.
+defaults to false. Incoming bytes and extraction are staged on the destination
+filesystem, so the final atomic rename also works when the Portacode cache and
+destination are on different mounts. Payload and entry ceilings default to 10
+GiB and 100,000 entries and are configurable by the device operator.
 
 Returns `transfer_prepared` with sizes, storage estimates, and progress.
 

{portacode-1.5.21.dev0 → portacode-1.5.21.dev2}/portacode/connection/handlers/resumable_transfer_handlers.py

@@ -29,6 +29,8 @@ MIN_CHUNK_SIZE = 32 * 1024
 MAX_CHUNK_SIZE = 1024 * 1024
 TRANSFER_TTL_SECONDS = 24 * 60 * 60
 STORAGE_SAFETY_BYTES = 16 * 1024 * 1024
+MAX_TRANSFER_PAYLOAD_BYTES = int(os.environ.get("PORTACODE_TRANSFER_MAX_PAYLOAD_BYTES", 10 * 1024 * 1024 * 1024))
+MAX_TRANSFER_ENTRIES = int(os.environ.get("PORTACODE_TRANSFER_MAX_ENTRIES", 100_000))
 
 
 def _cache_root() -> Path:
@@ -134,15 +136,20 @@ def _folder_metrics(path: Path) -> Dict[str, int]:
     entries = 1
     for root, directories, files in os.walk(path, followlinks=False):
         entries += len(directories) + len(files)
+        for name in directories:
+            item = Path(root) / name
+            info = item.lstat()
+            if stat.S_ISLNK(info.st_mode):
+                raise ValueError(f"Folder transfers do not support symbolic links: {item}")
         for name in files:
             item = Path(root) / name
-            try:
-                info = item.lstat()
-            except OSError:
-                continue
-            if stat.S_ISREG(info.st_mode):
-                logical += info.st_size
-                allocated += max(info.st_blocks * 512, info.st_size)
+            info = item.lstat()
+            if stat.S_ISLNK(info.st_mode):
+                raise ValueError(f"Folder transfers do not support symbolic links: {item}")
+            if not stat.S_ISREG(info.st_mode):
+                raise ValueError(f"Folder transfers do not support special files: {item}")
+            logical += info.st_size
+            allocated += max(info.st_blocks * 512, info.st_size)
     return {"expanded_size": logical, "expanded_storage_bytes": allocated, "entry_count": entries}
 
 
@@ -184,11 +191,37 @@ def _cleanup_expired() -> None:
             manifest = json.loads((child / "manifest.json").read_text(encoding="utf-8"))
             expired = float(manifest.get("expires_at") or 0) <= now
         except Exception:
+            manifest = None
             expired = child.stat().st_mtime < now - TRANSFER_TTL_SECONDS
         if expired:
+            if manifest:
+                _cleanup_destination_staging(manifest)
             shutil.rmtree(child, ignore_errors=True)
 
 
+def _cleanup_destination_staging(manifest: Dict[str, Any]) -> None:
+    """Remove only UUID-bound staging names outside the cache directory."""
+    transfer_id = str(manifest.get("transfer_id") or "")
+    expected = {
+        f".portacode-incoming-{transfer_id}.part": "file",
+        f".portacode-staged-{transfer_id}": "file",
+        f".portacode-extract-{transfer_id}": "directory",
+    }
+    for key in ("partial_path", "staged_path", "extraction_path"):
+        raw = manifest.get(key)
+        if not raw:
+            continue
+        path = Path(str(raw))
+        kind = expected.get(path.name)
+        try:
+            if kind == "directory":
+                shutil.rmtree(path, ignore_errors=True)
+            elif kind == "file":
+                path.unlink(missing_ok=True)
+        except OSError:
+            pass
+
+
 def _prepare_source(message: Dict[str, Any]) -> Dict[str, Any]:
     transfer_id = _transfer_id(message.get("transfer_id"))
     token = _authorization_token(message.get("authorization_token"))
@@ -212,9 +245,18 @@ def _prepare_source(message: Dict[str, Any]) -> Dict[str, Any]:
     metrics = {"expanded_size": source.stat().st_size, "expanded_storage_bytes": source.stat().st_size, "entry_count": 1}
     payload = source
     archive_format = None
+    if kind == "file" and source.stat().st_size > MAX_TRANSFER_PAYLOAD_BYTES:
+        shutil.rmtree(job_dir, ignore_errors=True)
+        raise ValueError(f"Transfer payload exceeds the {MAX_TRANSFER_PAYLOAD_BYTES} byte limit")
     if kind == "folder":
         metrics = _folder_metrics(source)
+        if metrics["entry_count"] > MAX_TRANSFER_ENTRIES:
+            shutil.rmtree(job_dir, ignore_errors=True)
+            raise ValueError(f"Folder exceeds the {MAX_TRANSFER_ENTRIES} entry limit")
         estimate = _estimated_tar_bytes(metrics)
+        if estimate > MAX_TRANSFER_PAYLOAD_BYTES:
+            shutil.rmtree(job_dir, ignore_errors=True)
+            raise ValueError(f"Estimated folder archive exceeds the {MAX_TRANSFER_PAYLOAD_BYTES} byte limit")
         available = _free_bytes(job_dir)
         required = estimate + STORAGE_SAFETY_BYTES
         if available < required:
@@ -229,6 +271,9 @@ def _prepare_source(message: Dict[str, Any]) -> Dict[str, Any]:
             shutil.rmtree(job_dir, ignore_errors=True)
             raise
         source_extra_required = payload.stat().st_size
+        if source_extra_required > MAX_TRANSFER_PAYLOAD_BYTES:
+            shutil.rmtree(job_dir, ignore_errors=True)
+            raise ValueError(f"Transfer payload exceeds the {MAX_TRANSFER_PAYLOAD_BYTES} byte limit")
         archive_format = "tar"
 
     payload_size = payload.stat().st_size
@@ -273,6 +318,10 @@ def _prepare_destination(message: Dict[str, Any]) -> Dict[str, Any]:
     entry_count = int(message.get("entry_count") or 1)
     if payload_size < 0 or expanded_storage < 0:
         raise ValueError("payload_size and expanded_storage_bytes must be non-negative")
+    if payload_size > MAX_TRANSFER_PAYLOAD_BYTES:
+        raise ValueError(f"Transfer payload exceeds the {MAX_TRANSFER_PAYLOAD_BYTES} byte limit")
+    if entry_count < 1 or entry_count > MAX_TRANSFER_ENTRIES:
+        raise ValueError(f"entry_count must be between 1 and {MAX_TRANSFER_ENTRIES}")
     if destination.exists() and not bool(message.get("overwrite", False)):
         raise ValueError(f"Destination already exists: {destination}")
     job_dir = _job_dir(transfer_id)
@@ -290,7 +339,8 @@ def _prepare_destination(message: Dict[str, Any]) -> Dict[str, Any]:
         shutil.rmtree(job_dir, ignore_errors=True)
         raise _storage_error(side="destination", path=destination, required=required,
                              available=available, archive=payload_size, extraction=extraction)
-    partial = job_dir / "incoming.part"
+    staging_parent = _nearest_existing_parent(destination)
+    partial = staging_parent / f".portacode-incoming-{transfer_id}.part"
     with partial.open("wb") as stream:
         stream.truncate(payload_size)
     manifest = {
@@ -302,6 +352,8 @@ def _prepare_destination(message: Dict[str, Any]) -> Dict[str, Any]:
         "state": "receiving",
         "destination_path": str(destination),
         "partial_path": str(partial),
+        "staged_path": str(staging_parent / f".portacode-staged-{transfer_id}"),
+        "extraction_path": str(staging_parent / f".portacode-extract-{transfer_id}"),
         "payload_size": payload_size,
         "payload_hash": str(message.get("payload_hash") or ""),
         "chunk_size": min(max(int(message.get("chunk_size") or DEFAULT_CHUNK_SIZE), MIN_CHUNK_SIZE), MAX_CHUNK_SIZE),
@@ -409,13 +461,11 @@ def _safe_members(archive: tarfile.TarFile, root: Path) -> Iterable[tarfile.TarI
             raise ValueError(f"Archive path escapes destination: {member.name}")
         if member.ischr() or member.isblk() or member.isfifo():
             raise ValueError(f"Unsupported special file in archive: {member.name}")
+        # Reject links entirely.  Merely checking each link target is not
+        # sufficient because a later member can traverse a symlink created by
+        # an earlier member during extraction.
         if member.issym() or member.islnk():
-            link = PurePosixPath(member.linkname)
-            if link.is_absolute():
-                raise ValueError(f"Absolute archive link is forbidden: {member.name}")
-            link_destination = (destination.parent / Path(*link.parts)).resolve()
-            if os.path.commonpath((str(root_resolved), str(link_destination))) != str(root_resolved):
-                raise ValueError(f"Archive link escapes destination: {member.name}")
+            raise ValueError(f"Archive links are forbidden: {member.name}")
         yield member
 
 
@@ -427,7 +477,7 @@ def _apply_metadata(path: Path, metadata: Dict[str, Any]) -> Dict[str, bool]:
     except (OSError, NotImplementedError):
         # Some Unix builds expose follow_symlinks but do not implement it for
         # chmod. Staged file payloads are verified regular files.
-        if path.is_file() and not path.is_symlink():
+        if (path.is_file() or path.is_dir()) and not path.is_symlink():
             try:
                 os.chmod(path, int(metadata["mode"]))
                 result["mode"] = True
@@ -448,6 +498,34 @@ def _apply_metadata(path: Path, metadata: Dict[str, Any]) -> Dict[str, bool]:
     return result
 
 
+def _restore_archive_metadata(root: Path, members: Iterable[tarfile.TarInfo]) -> Dict[str, bool]:
+    """Restore validated tar metadata consistently across Python versions.
+
+    Python 3.14's default tar extraction filter intentionally removes group
+    and other write bits. The archive has already passed our stricter path,
+    link, and special-file validation, so reapply its recorded metadata after
+    extraction. Directories are handled last so creating their children does
+    not overwrite their timestamps.
+    """
+    results = {"mode": True, "ownership": True, "timestamps": True}
+    ordered = sorted(members, key=lambda item: (item.isdir(), -len(PurePosixPath(item.name).parts)))
+    for member in ordered:
+        target = root / Path(*PurePosixPath(member.name).parts)
+        pax = member.pax_headers or {}
+        timestamp = float(pax.get("mtime", member.mtime))
+        metadata = {
+            "mode": member.mode,
+            "uid": member.uid,
+            "gid": member.gid,
+            "atime_ns": int(float(pax.get("atime", timestamp)) * 1_000_000_000),
+            "mtime_ns": int(timestamp * 1_000_000_000),
+        }
+        applied = _apply_metadata(target, metadata)
+        for key, value in applied.items():
+            results[key] = results[key] and value
+    return results
+
+
 def _install_path(staged: Path, destination: Path, overwrite: bool) -> None:
     destination.parent.mkdir(parents=True, exist_ok=True)
     backup = None
@@ -485,12 +563,15 @@ def _finalize(message: Dict[str, Any]) -> Dict[str, Any]:
     destination = Path(manifest["destination_path"])
     metadata_result: Dict[str, bool] = {}
     if manifest["kind"] == "file":
-        staged = partial.with_name("staged-file")
+        staged = Path(manifest.get("staged_path") or partial.with_name(f".portacode-staged-{manifest['transfer_id']}"))
+        staged.unlink(missing_ok=True)
         os.replace(partial, staged)
         metadata_result = _apply_metadata(staged, manifest.get("metadata") or {})
         _install_path(staged, destination, bool(manifest.get("overwrite")))
     else:
-        extraction_root = _job_dir(manifest["transfer_id"]) / "extracted"
+        extraction_root = Path(manifest.get("extraction_path") or (
+            _nearest_existing_parent(destination) / f".portacode-extract-{manifest['transfer_id']}"
+        ))
         shutil.rmtree(extraction_root, ignore_errors=True)
         extraction_root.mkdir(mode=0o700)
         with tarfile.open(partial, "r:") as archive:
@@ -498,6 +579,7 @@ def _finalize(message: Dict[str, Any]) -> Dict[str, Any]:
             if len(members) != int(manifest.get("entry_count") or len(members)):
                 raise ValueError("Archive entry count differs from the authorized manifest")
             archive.extractall(extraction_root, members=members, numeric_owner=True)
+            metadata_result = _restore_archive_metadata(extraction_root, members)
         roots = list(extraction_root.iterdir())
         if len(roots) != 1:
             raise ValueError("Folder archive must contain exactly one root item")
@@ -578,5 +660,6 @@ class TransferCancelHandler(SyncHandler):
     def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
         manifest = _load_manifest(message.get("transfer_id"), message.get("authorization_token"))
         transfer_id = manifest["transfer_id"]
+        _cleanup_destination_staging(manifest)
         shutil.rmtree(_job_dir(transfer_id), ignore_errors=True)
         return {"event": "transfer_canceled", "transfer_id": transfer_id, "success": True}

{portacode-1.5.21.dev0 → portacode-1.5.21.dev2}/portacode/tests/test_codex_loopback_proxy.py

@@ -13,6 +13,7 @@ from cryptography.hazmat.primitives.asymmetric import rsa
 from cryptography.hazmat.primitives.serialization import Encoding, NoEncryption, PrivateFormat, PublicFormat
 
 from portacode.codex_loopback_proxy import (
+    MAX_FORWARD_REQUEST_BYTES,
     MAX_REQUEST_BYTES,
     MAX_TOOL_OUTPUT_BYTES,
     CodexLoopbackProxy,
@@ -82,6 +83,33 @@ def test_ingress_limit_leaves_room_to_crop_oversized_tool_output():
     assert len(sanitized) < len(body)
     assert changed == 1
     assert omitted > 10 * 1024 * 1024 - MAX_TOOL_OUTPUT_BYTES
+
+
+def test_sanitize_omits_oldest_inline_tool_images_to_fit_forward_limit():
+    image = "data:image/png;base64," + ("a" * (3 * 1024 * 1024))
+    body = json.dumps({
+        "input": [
+            {
+                "type": "custom_tool_call_output",
+                "call_id": f"call-{index}",
+                "output": [
+                    {"type": "input_text", "text": f"screenshot {index}"},
+                    {"type": "input_image", "image_url": image, "detail": "high"},
+                ],
+            }
+            for index in range(4)
+        ]
+    }).encode()
+
+    sanitized, changed, omitted = sanitize_responses_request(body)
+    payload = json.loads(sanitized)
+
+    assert len(sanitized) <= MAX_FORWARD_REQUEST_BYTES
+    assert changed == 1
+    assert omitted >= len(image)
+    assert payload["input"][0]["output"][1]["type"] == "input_text"
+    assert "omitted an older inline tool screenshot" in payload["input"][0]["output"][1]["text"]
+    assert payload["input"][-1]["output"][1]["image_url"] == image
 from portacode.keypair import KeyPair
 
 

portacode-1.5.21.dev2/portacode/tests/test_resumable_transfer_handlers.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+import os
+import stat
+import io
+import tarfile
+import uuid
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from portacode.connection.handlers.resumable_transfer_handlers import (
+    STORAGE_SAFETY_BYTES,
+    TransferFinalizeHandler,
+    TransferCancelHandler,
+    TransferPrepareHandler,
+    TransferReadChunkHandler,
+    TransferReceiveChunkHandler,
+    TransferStatusHandler,
+)
+
+
+TOKEN = "transfer-authorization-token-with-ample-entropy"
+
+
+def _handler(handler_class):
+    return handler_class(None, {})
+
+
+def _copy_all_chunks(source_cache: Path, destination_cache: Path, prepared: dict, destination: Path):
+    transfer_id = prepared["transfer_id"]
+    common = {
+        "transfer_id": transfer_id,
+        "authorization_token": TOKEN,
+    }
+    os.environ["PORTACODE_TRANSFER_CACHE_DIR"] = str(destination_cache)
+    destination_prepared = _handler(TransferPrepareHandler).execute({
+        **common,
+        "role": "destination",
+        "kind": prepared["kind"],
+        "path": str(destination),
+        "payload_size": prepared["payload_size"],
+        "payload_hash": prepared["payload_hash"],
+        "chunk_size": prepared["chunk_size"],
+        "chunk_count": prepared["chunk_count"],
+        "expanded_size": prepared["expanded_size"],
+        "expanded_storage_bytes": prepared["expanded_storage_bytes"],
+        "entry_count": prepared["entry_count"],
+        "metadata": prepared["metadata"],
+        "archive_format": prepared["archive_format"],
+    })
+    assert destination_prepared["progress_percent"] == 0
+
+    for index in range(prepared["chunk_count"]):
+        os.environ["PORTACODE_TRANSFER_CACHE_DIR"] = str(source_cache)
+        chunk = _handler(TransferReadChunkHandler).execute({**common, "chunk_index": index})
+        os.environ["PORTACODE_TRANSFER_CACHE_DIR"] = str(destination_cache)
+        received = _handler(TransferReceiveChunkHandler).execute({
+            **common,
+            "chunk_index": index,
+            "chunk_hash": chunk["chunk_hash"],
+            "content_base64": chunk["content_base64"],
+        })
+        expected = round(received["completed_bytes"] * 100 / max(received["payload_size"], 1), 2)
+        assert received["progress_percent"] == expected
+
+    # A newly constructed handler reads the persisted receipt map, simulating
+    # both a WebSocket reconnect and a device-agent restart.
+    status = _handler(TransferStatusHandler).execute(common)
+    assert status["missing_chunks"] == []
+    assert status["progress_percent"] == 100
+    return _handler(TransferFinalizeHandler).execute(common)
+
+
+def test_file_transfer_resumes_and_preserves_metadata(tmp_path, monkeypatch):
+    source_cache = tmp_path / "source-cache"
+    destination_cache = tmp_path / "destination-cache"
+    source = tmp_path / "source.bin"
+    source.write_bytes((b"portacode-transfer" * 20000) + b"tail")
+    source.chmod(0o640)
+    transfer_id = str(uuid.uuid4())
+    monkeypatch.setenv("PORTACODE_TRANSFER_CACHE_DIR", str(source_cache))
+    prepared = _handler(TransferPrepareHandler).execute({
+        "role": "source",
+        "kind": "file",
+        "path": str(source),
+        "transfer_id": transfer_id,
+        "authorization_token": TOKEN,
+        "chunk_size": 64 * 1024,
+    })
+
+    destination = tmp_path / "received.bin"
+    finalized = _copy_all_chunks(source_cache, destination_cache, prepared, destination)
+
+    assert destination.read_bytes() == source.read_bytes()
+    assert stat.S_IMODE(destination.stat().st_mode) == 0o640
+    assert finalized["complete"] is True
+    assert finalized["metadata_preserved"]["mode"] is True
+
+
+def test_folder_transfer_resumes_and_preserves_tree_metadata(tmp_path, monkeypatch):
+    source_cache = tmp_path / "source-cache"
+    destination_cache = tmp_path / "destination-cache"
+    source = tmp_path / "assets"
+    (source / "nested").mkdir(parents=True)
+    (source / "nested" / "photo.bin").write_bytes(b"image" * 30000)
+    (source / "readme.txt").write_text("hello", encoding="utf-8")
+    (source / "nested" / "photo.bin").chmod(0o600)
+    (source / "readme.txt").chmod(0o664)
+    (source / "nested").chmod(0o770)
+    transfer_id = str(uuid.uuid4())
+    monkeypatch.setenv("PORTACODE_TRANSFER_CACHE_DIR", str(source_cache))
+    prepared = _handler(TransferPrepareHandler).execute({
+        "role": "source",
+        "kind": "folder",
+        "path": str(source),
+        "transfer_id": transfer_id,
+        "authorization_token": TOKEN,
+        "chunk_size": 64 * 1024,
+    })
+
+    destination = tmp_path / "copied-assets"
+    finalized = _copy_all_chunks(source_cache, destination_cache, prepared, destination)
+
+    assert (destination / "readme.txt").read_text(encoding="utf-8") == "hello"
+    assert (destination / "nested" / "photo.bin").read_bytes() == b"image" * 30000
+    assert stat.S_IMODE((destination / "nested" / "photo.bin").stat().st_mode) == 0o600
+    assert stat.S_IMODE((destination / "readme.txt").stat().st_mode) == 0o664
+    assert stat.S_IMODE((destination / "nested").stat().st_mode) == 0o770
+    assert finalized["kind"] == "folder"
+    assert finalized["metadata_preserved"]["mode"] is True
+
+
+def test_transfer_token_is_bound_and_required(tmp_path, monkeypatch):
+    monkeypatch.setenv("PORTACODE_TRANSFER_CACHE_DIR", str(tmp_path / "cache"))
+    source = tmp_path / "source.txt"
+    source.write_text("secret", encoding="utf-8")
+    transfer_id = str(uuid.uuid4())
+    _handler(TransferPrepareHandler).execute({
+        "role": "source",
+        "kind": "file",
+        "path": str(source),
+        "transfer_id": transfer_id,
+        "authorization_token": TOKEN,
+    })
+
+    with pytest.raises(PermissionError, match="authorization is invalid"):
+        _handler(TransferStatusHandler).execute({
+            "transfer_id": transfer_id,
+            "authorization_token": "a-different-token-with-enough-characters",
+        })
+
+
+def test_destination_reports_peak_storage_deficit(tmp_path, monkeypatch):
+    monkeypatch.setenv("PORTACODE_TRANSFER_CACHE_DIR", str(tmp_path / "cache"))
+    transfer_id = str(uuid.uuid4())
+    payload_size = 20 * 1024 * 1024
+    expanded = 80 * 1024 * 1024
+    available = 10 * 1024 * 1024
+    with patch(
+        "portacode.connection.handlers.resumable_transfer_handlers._free_bytes",
+        return_value=available,
+    ), patch(
+        "portacode.connection.handlers.resumable_transfer_handlers._filesystem_block_size",
+        return_value=4096,
+    ), pytest.raises(ValueError) as error:
+        _handler(TransferPrepareHandler).execute({
+            "role": "destination",
+            "kind": "folder",
+            "path": str(tmp_path / "destination"),
+            "transfer_id": transfer_id,
+            "authorization_token": TOKEN,
+            "payload_size": payload_size,
+            "payload_hash": "a" * 64,
+            "expanded_storage_bytes": expanded,
+            "chunk_size": 64 * 1024,
+            "chunk_count": payload_size // (64 * 1024),
+        })
+    entry_overhead = 4096
+    required = payload_size + expanded + entry_overhead + STORAGE_SAFETY_BYTES
+    message = str(error.value)
+    assert f"required {required} bytes" in message
+    assert f"available {available} bytes" in message
+    assert f"short by {required - available} bytes" in message
+
+
+def test_folder_finalize_rejects_symlink_chain_archive(tmp_path, monkeypatch):
+    cache = tmp_path / "cache"
+    monkeypatch.setenv("PORTACODE_TRANSFER_CACHE_DIR", str(cache))
+    transfer_id = str(uuid.uuid4())
+    payload = tmp_path / "hostile.tar"
+    with tarfile.open(payload, "w") as archive:
+        root = tarfile.TarInfo("root/")
+        root.type = tarfile.DIRTYPE
+        archive.addfile(root)
+        link = tarfile.TarInfo("root/pivot")
+        link.type = tarfile.SYMTYPE
+        link.linkname = "."
+        archive.addfile(link)
+        content = b"must not extract"
+        nested = tarfile.TarInfo("root/pivot/file.txt")
+        nested.size = len(content)
+        archive.addfile(nested, io.BytesIO(content))
+
+    digest = __import__("hashlib").sha256(payload.read_bytes()).hexdigest()
+    common = {"transfer_id": transfer_id, "authorization_token": TOKEN}
+    prepared = _handler(TransferPrepareHandler).execute({
+        **common, "role": "destination", "kind": "folder",
+        "path": str(tmp_path / "output"), "payload_size": payload.stat().st_size,
+        "payload_hash": digest, "chunk_size": 64 * 1024,
+        "chunk_count": 1, "expanded_storage_bytes": len(content), "entry_count": 3,
+    })
+    received = _handler(TransferReceiveChunkHandler).execute({
+        **common, "chunk_index": 0, "chunk_hash": digest,
+        "content_base64": __import__("base64").b64encode(payload.read_bytes()).decode(),
+    })
+    assert received["progress_percent"] == 100
+    with pytest.raises(ValueError, match="Archive links are forbidden"):
+        _handler(TransferFinalizeHandler).execute(common)
+    assert not (tmp_path / "output").exists()
+
+
+def test_destination_stages_on_destination_filesystem_and_cancel_cleans_it(tmp_path, monkeypatch):
+    cache = tmp_path / "cache"
+    destination_root = tmp_path / "destination-filesystem"
+    destination_root.mkdir()
+    destination = destination_root / "nested" / "received.bin"
+    monkeypatch.setenv("PORTACODE_TRANSFER_CACHE_DIR", str(cache))
+    transfer_id = str(uuid.uuid4())
+    common = {"transfer_id": transfer_id, "authorization_token": TOKEN}
+    _handler(TransferPrepareHandler).execute({
+        **common, "role": "destination", "kind": "file", "path": str(destination),
+        "payload_size": 4, "payload_hash": "0" * 64, "chunk_size": 32768,
+        "chunk_count": 1, "expanded_storage_bytes": 4, "entry_count": 1,
+    })
+    manifest = __import__("json").loads((cache / transfer_id / "manifest.json").read_text())
+    partial = Path(manifest["partial_path"])
+    assert partial.parent == destination_root
+    assert partial.exists()
+    _handler(TransferCancelHandler).execute(common)
+    assert not partial.exists()
+    assert not (cache / transfer_id).exists()
+
+
+def test_folder_source_rejects_links_before_archiving(tmp_path, monkeypatch):
+    source = tmp_path / "source"
+    source.mkdir()
+    (source / "real.txt").write_text("data", encoding="utf-8")
+    (source / "link.txt").symlink_to("real.txt")
+    monkeypatch.setenv("PORTACODE_TRANSFER_CACHE_DIR", str(tmp_path / "cache"))
+    with pytest.raises(ValueError, match="do not support symbolic links"):
+        _handler(TransferPrepareHandler).execute({
+            "role": "source", "kind": "folder", "path": str(source),
+            "transfer_id": str(uuid.uuid4()), "authorization_token": TOKEN,
+        })

{portacode-1.5.21.dev0 → portacode-1.5.21.dev2}/portacode.egg-info/PKG-INFO

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