portacode 1.5.18.dev0__tar.gz → 1.5.19.dev1__tar.gz

{portacode-1.5.18.dev0 → portacode-1.5.19.dev1}/.gitignore

@@ -10,6 +10,8 @@ client_sessions.json
 project_state_debug.json
 test_results
 logs
+AGENTS.md
+secrets
 
 # Example-generated volumes
 examples/simple_device/data/

{portacode-1.5.18.dev0 → portacode-1.5.19.dev1}/Makefile

@@ -1,6 +1,8 @@
 # Makefile for Python package release automation
 
-.PHONY: release
+.PHONY: release
+
+PUSH_RELEASE_TAG ?= 1
 
 release:
 	@echo "Usage: make release VERSION=x.y.z [or just 'make release' for date-based version]"
@@ -15,9 +17,11 @@ else
 	rm -rf dist/*
 	# Ensure we're on a clean state
 	git pull
-	# Create and push the tag
-	git tag -f v$(VERSION)
-	git push -f origin v$(VERSION)
+	# Create and push the tag
+	git tag -f v$(VERSION)
+ifeq ($(PUSH_RELEASE_TAG),1)
+	git push -f origin v$(VERSION)
+endif
 	# Clean any previous builds
 	rm -rf build/ *.egg-info
 	# Build from the tagged state
@@ -26,4 +30,4 @@ else
 endif
 
 # Default target
-release: release-real 
+release: release-real

{portacode-1.5.18.dev0 → portacode-1.5.19.dev1}/PKG-INFO

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

{portacode-1.5.18.dev0 → portacode-1.5.19.dev1}/portacode/_version.py

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

{portacode-1.5.18.dev0 → portacode-1.5.19.dev1}/portacode/cli.py

@@ -9,13 +9,15 @@ from pathlib import Path
 import signal
 import json
 import socket
+import time
 from typing import Optional, Tuple
 
 import click
 import pyperclip
 
 from . import __version__
-from .data import get_pid_file, is_process_running
+from .data import get_gateway_lock_file, get_pid_file, is_process_running
+from .singleton import GatewayLock
 from .keypair import (
     get_or_create_keypair,
     fingerprint_public_key,
@@ -64,6 +66,18 @@ def prepare_codex_command() -> None:
     )
 
 
+@cli.command("github-setup")
+def github_setup_command() -> None:
+    """Configure Git to request device-scoped GitHub credentials from Portacode."""
+    from .github_credential import configure_git
+
+    try:
+        configure_git()
+    except (OSError, subprocess.CalledProcessError) as exc:
+        raise click.ClickException(f"Could not configure GitHub access: {exc}") from exc
+    click.echo(click.style("GitHub access is configured for this device.", fg="green"))
+
+
 @cli.command()
 @click.option("--gateway", "gateway", "-g", help="Gateway websocket URL (overrides env/ default)")
 @click.option("--debug", "debug", is_flag=True, help="Enable debug logging")
@@ -164,8 +178,38 @@ def connect(
             format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
         )
 
-    # 1. Ensure only a single connection per user
+    # 1. Ensure only a single connection per host.  The lifetime-held lock is
+    # atomic; the historical PID file is retained so rolling upgrades can
+    # interoperate with older Portacode versions.
     pid_file = get_pid_file()
+    gateway_lock = GatewayLock(get_gateway_lock_file())
+    if not gateway_lock.acquire():
+        other_pid = gateway_lock.read_pid()
+        message = "Another portacode connection is active."
+        if other_pid:
+            message = f"Another portacode connection (PID {other_pid}) is active."
+        click.echo(click.style(message, fg="yellow"))
+
+        replace = non_interactive
+        if not non_interactive:
+            replace = click.confirm("Terminate the existing connection?", default=False)
+        if not replace:
+            click.echo("Aborting.")
+            sys.exit(1)
+        if not other_pid or not is_process_running(other_pid):
+            click.echo(click.style("Unable to identify the lock owner; aborting safely.", fg="red"))
+            sys.exit(1)
+
+        if non_interactive:
+            click.echo(click.style("Non-interactive mode: terminating the existing connection automatically.", fg="bright_black"))
+        _terminate_process(other_pid)
+        deadline = time.monotonic() + 5.0
+        while time.monotonic() < deadline and not gateway_lock.acquire():
+            time.sleep(0.05)
+        if not gateway_lock.held:
+            click.echo(click.style("Existing connection did not release the singleton lock; aborting.", fg="red"))
+            sys.exit(1)
+
     if pid_file.exists():
         try:
             other_pid = int(pid_file.read_text())
@@ -191,13 +235,17 @@ def connect(
                 if non_interactive:
                     click.echo(click.style("Non-interactive mode: terminating the existing connection automatically.", fg="bright_black"))
                     _terminate_process(other_pid)
-                    pid_file.unlink(missing_ok=True)
                 elif click.confirm("Terminate the existing connection?", default=False):
                     _terminate_process(other_pid)
-                    pid_file.unlink(missing_ok=True)
                 else:
                     click.echo("Aborting.")
                     sys.exit(1)
+                _wait_for_process_exit(other_pid, timeout=5.0)
+                try:
+                    if int(pid_file.read_text()) == other_pid:
+                        pid_file.unlink(missing_ok=True)
+                except (FileNotFoundError, ValueError, OSError):
+                    pass
         else:
             # Stale pidfile
             pid_file.unlink(missing_ok=True)
@@ -408,9 +456,11 @@ def connect(
 
     if exit_after_setup:
         click.echo(click.style("Bootstrap steps completed. Exiting without starting a live connection.", fg="green"))
+        gateway_lock.release()
         return
 
     pid_file.write_text(str(os.getpid()))
+    gateway_lock.write_pid(os.getpid())
 
     async def _main() -> None:
         mgr = ConnectionManager(
@@ -424,7 +474,14 @@ def connect(
     try:
         asyncio.run(_main())
     finally:
-        pid_file.unlink(missing_ok=True)
+        # An older client may have replaced this file while we were shutting
+        # down.  Never delete a PID file that no longer belongs to us.
+        try:
+            if int(pid_file.read_text()) == os.getpid():
+                pid_file.unlink(missing_ok=True)
+        except (FileNotFoundError, ValueError, OSError):
+            pass
+        gateway_lock.release()
 
 
 def _terminate_process(pid: int):
@@ -442,6 +499,15 @@ def _terminate_process(pid: int):
             pass
 
 
+def _wait_for_process_exit(pid: int, timeout: float) -> bool:
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if not is_process_running(pid):
+            return True
+        time.sleep(0.05)
+    return not is_process_running(pid)
+
+
 def _is_transient_proxmox_setup_failure(reply: object) -> bool:
     if not isinstance(reply, dict):
         return True

{portacode-1.5.18.dev0 → portacode-1.5.19.dev1}/portacode/codex_loopback_proxy.py

@@ -29,13 +29,106 @@ LOGGER = logging.getLogger(__name__)
 CODEX_LOOPBACK_HOST = "127.0.0.1"
 CODEX_LOOPBACK_PORT = 61789
 DEFAULT_GATEWAY_URL = "https://codexapi.portacode.com/v1"
-MAX_REQUEST_BYTES = 10 * 1024 * 1024
+# Codex has already serialized local command output by the time it reaches this
+# proxy.  The ingress envelope therefore needs to be larger than the payload we
+# are willing to send upstream, otherwise oversized tool output is rejected
+# before ``sanitize_responses_request`` gets a chance to crop it.
+MAX_REQUEST_BYTES = 32 * 1024 * 1024
+MAX_FORWARD_REQUEST_BYTES = 10 * 1024 * 1024
+MAX_TOOL_OUTPUT_BYTES = 64 * 1024
+MAX_TOTAL_TOOL_OUTPUT_BYTES = 256 * 1024
 ALLOWED_PATHS = {"/health", "/v1/models", "/v1/responses"}
 MAX_CONCURRENT_UPSTREAM = 8
 
 # Streaming read can idle between SSE chunks; connect/write stay bounded.
 _UPSTREAM_TIMEOUT = httpx.Timeout(connect=20.0, read=600.0, write=60.0, pool=20.0)
 
+_TOOL_OUTPUT_TYPES = frozenset(
+    {
+        "function_call_output",
+        "computer_call_output",
+        "custom_tool_call_output",
+        "local_shell_call_output",
+        "shell_call_output",
+        "command_execution_output",
+    }
+)
+
+
+def _truncate_utf8(value: str, limit: int = MAX_TOOL_OUTPUT_BYTES) -> tuple[str, int]:
+    """Keep useful head/tail context while enforcing a UTF-8 byte ceiling."""
+    raw = value.encode("utf-8")
+    if len(raw) <= limit:
+        return value, 0
+    if limit <= 0:
+        return "", len(raw)
+    marker_budget = 160
+    content_budget = max(limit - marker_budget, 0)
+    head_size = content_budget * 3 // 4
+    tail_size = content_budget - head_size
+    head = raw[:head_size].decode("utf-8", errors="ignore")
+    tail = raw[-tail_size:].decode("utf-8", errors="ignore") if tail_size else ""
+    omitted = len(raw) - len(head.encode("utf-8")) - len(tail.encode("utf-8"))
+    marker = (
+        f"\n\n[Portacode truncated {omitted} bytes of oversized tool output. "
+        "Narrow the command or inspect a specific file.]\n\n"
+    )
+    if len(marker.encode("utf-8")) >= limit:
+        return marker.encode("utf-8")[:limit].decode("utf-8", errors="ignore"), len(raw)
+    result = f"{head}{marker}{tail}"
+    # The dynamic marker can exceed marker_budget by a few bytes.
+    while len(result.encode("utf-8")) > limit and head:
+        head = head[:-128]
+        result = f"{head}{marker}{tail}"
+    return result, omitted
+
+
+def sanitize_responses_request(body: bytes) -> tuple[bytes, int, int]:
+    """Crop only recognized Responses API tool-result fields.
+
+    Unknown JSON shapes pass through untouched so Codex/API upgrades cannot be
+    silently corrupted. Returns (body, fields_changed, bytes_omitted).
+    """
+    try:
+        payload = json.loads(body)
+    except (json.JSONDecodeError, UnicodeDecodeError):
+        return body, 0, 0
+    if not isinstance(payload, dict) or not isinstance(payload.get("input"), list):
+        return body, 0, 0
+
+    changed = 0
+    omitted_total = 0
+    retained_total = 0
+    for item in payload["input"]:
+        if not isinstance(item, dict) or item.get("type") not in _TOOL_OUTPUT_TYPES:
+            continue
+        for key in ("output", "content"):
+            value = item.get(key)
+            if isinstance(value, str):
+                remaining = max(MAX_TOTAL_TOOL_OUTPUT_BYTES - retained_total, 0)
+                cropped, omitted = _truncate_utf8(value, min(MAX_TOOL_OUTPUT_BYTES, remaining))
+                if omitted:
+                    item[key] = cropped
+                    changed += 1
+                    omitted_total += omitted
+                retained_total += len(cropped.encode("utf-8"))
+            elif isinstance(value, list):
+                for part in value:
+                    if not isinstance(part, dict) or not isinstance(part.get("text"), str):
+                        continue
+                    remaining = max(MAX_TOTAL_TOOL_OUTPUT_BYTES - retained_total, 0)
+                    cropped, omitted = _truncate_utf8(
+                        part["text"], min(MAX_TOOL_OUTPUT_BYTES, remaining)
+                    )
+                    if omitted:
+                        part["text"] = cropped
+                        changed += 1
+                        omitted_total += omitted
+                    retained_total += len(cropped.encode("utf-8"))
+    if not changed:
+        return body, 0, 0
+    return json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8"), changed, omitted_total
+
 FORWARD_RESPONSE_HEADERS = frozenset(
     {
         "content-type",
@@ -366,6 +459,19 @@ class CodexLoopbackProxy:
         *,
         req_id: str,
     ) -> None:
+        if method == "POST" and path == "/v1/responses" and body:
+            body, cropped_fields, omitted_bytes = sanitize_responses_request(body)
+            if cropped_fields:
+                LOGGER.warning(
+                    "codex-proxy[%s] cropped %s oversized tool result field(s), omitting %s bytes",
+                    req_id,
+                    cropped_fields,
+                    omitted_bytes,
+                )
+            if len(body) > MAX_FORWARD_REQUEST_BYTES:
+                raise ValueError(
+                    "Request body remains too large after local tool-output truncation"
+                )
         headers = self._signature_headers(method, path, body)
         content_type = request_headers.get("content-type")
         if content_type:

{portacode-1.5.18.dev0 → portacode-1.5.19.dev1}/portacode/connection/client.py

@@ -213,6 +213,16 @@ class ConnectionManager:
             else:
                 print("Press Ctrl+C to close the connection.")
         # Finished authentication flow.
+        try:
+            from portacode.github_credential import configure_git
+
+            await asyncio.to_thread(configure_git)
+        except Exception as exc:
+            logger.warning(
+                "Could not configure device-scoped GitHub credentials: %s",
+                LogCategory.CONNECTION,
+                exc,
+            )
         await self._register_initial_project_paths()
 
     async def _start_codex_loopback_proxy(self) -> None:

{portacode-1.5.18.dev0 → portacode-1.5.19.dev1}/portacode/connection/codex_app_server.py

@@ -14,6 +14,12 @@ from typing import Any, Awaitable, Callable, Dict, List, Optional
 LOGGER = logging.getLogger(__name__)
 
 DEFAULT_CODEX_COMMAND = ["codex", "app-server", "--listen", "stdio://"]
+# JSON-RPC is newline framed and command completion notifications may contain
+# the aggregate output.  This ingress envelope must be larger than the UI
+# output limit so the handler can crop the notification instead of readline()
+# dropping it before dispatch.  It remains bounded to protect the agent from a
+# runaway app-server process.
+CODEX_STDIO_MESSAGE_LIMIT = 32 * 1024 * 1024
 
 
 class CodexAppServerError(RuntimeError):
@@ -149,6 +155,7 @@ class CodexAppServer:
                 "stdout": asyncio.subprocess.PIPE,
                 "stderr": asyncio.subprocess.PIPE,
                 "env": child_env,
+                "limit": CODEX_STDIO_MESSAGE_LIMIT,
             }
             if spawn_cwd:
                 spawn_kwargs["cwd"] = spawn_cwd
@@ -292,7 +299,18 @@ class CodexAppServer:
         assert self._proc is not None and self._proc.stdout is not None
         try:
             while True:
-                line = await self._proc.stdout.readline()
+                try:
+                    line = await self._proc.stdout.readline()
+                except ValueError as exc:
+                    # asyncio converts an over-limit newline frame to
+                    # ValueError. Drop that one frame but keep consuming future
+                    # notifications; the app-server process is still healthy.
+                    LOGGER.error(
+                        "Dropping Codex app-server JSON-RPC frame larger than %s bytes: %s",
+                        CODEX_STDIO_MESSAGE_LIMIT,
+                        exc,
+                    )
+                    continue
                 if not line:
                     break
                 line = line.decode("utf-8", errors="replace").strip()
@@ -309,8 +327,8 @@ class CodexAppServer:
         except Exception:
             LOGGER.exception("codex app-server read loop failed")
         finally:
-            # Process exited; schedule a restart if not closed.
-            if not self._closed:
+            # A reader/protocol failure is not necessarily a process exit.
+            if not self._closed and self._proc is not None and self._proc.returncode is not None:
                 asyncio.create_task(self._on_reader_exit())
 
     async def _stderr_loop(self) -> None:

{portacode-1.5.18.dev0 → portacode-1.5.19.dev1}/portacode/connection/handlers/__init__.py

@@ -25,6 +25,7 @@ from .file_handlers import (
     FileCreateHandler,
     FolderCreateHandler,
     FileRenameHandler,
+    FileMoveCopyHandler,
     FileSearchHandler,
     ContentRequestHandler,
 )
@@ -93,6 +94,7 @@ __all__ = [
     "FileCreateHandler",
     "FolderCreateHandler",
     "FileRenameHandler",
+    "FileMoveCopyHandler",
     "FileSearchHandler",
     "ContentRequestHandler",
     "FileApplyDiffHandler",

{portacode-1.5.18.dev0 → portacode-1.5.19.dev1}/portacode/connection/handlers/codex_handlers.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import copy
 import logging
 import mimetypes
 from pathlib import Path
@@ -13,6 +14,11 @@ from portacode.connection.codex_app_server import CodexAppServer, CodexAppServer
 from portacode.connection.handlers.base import AsyncHandler
 
 LOGGER = logging.getLogger(__name__)
+MAX_UI_COMMAND_OUTPUT_BYTES = 256 * 1024
+MAX_LIVE_TEXT_BYTES = 512 * 1024
+MAX_LIVE_ITEMS_PER_THREAD = 64
+MAX_LIVE_SNAPSHOT_BYTES = 4 * 1024 * 1024
+MAX_TRACKED_LIVE_THREADS = 64
 
 _IMAGE_SUFFIXES = {
     ".png",
@@ -121,6 +127,9 @@ class CodexChatManager:
         self._cwd_project: Dict[str, str] = {}
         self._thread_active_turn: Dict[str, str] = {}
         self._thread_sessions: Dict[str, set[str]] = {}
+        # Materialized in-progress items live with the device agent, not a
+        # browser websocket. New/reconnected tabs receive these on resume.
+        self._thread_live_items: Dict[str, Dict[str, Dict[str, Any]]] = {}
         # Survives page reloads via codex_status so the IDE can restore UI.
         self._prepare_running = False
         self._prepare_step: Optional[str] = None
@@ -174,8 +183,16 @@ class CodexChatManager:
         turn_id = params.get("turnId") or turn.get("id")
         if thread_id and method == "turn/started" and turn_id:
             self._thread_active_turn[str(thread_id)] = str(turn_id)
+            self._thread_live_items[str(thread_id)] = {}
+            while len(self._thread_live_items) > MAX_TRACKED_LIVE_THREADS:
+                oldest = next(iter(self._thread_live_items))
+                if oldest == str(thread_id) and len(self._thread_live_items) > 1:
+                    oldest = next(key for key in self._thread_live_items if key != str(thread_id))
+                self._thread_live_items.pop(oldest, None)
         elif thread_id and method == "turn/completed":
             self._thread_active_turn.pop(str(thread_id), None)
+        if thread_id:
+            params = self._materialize_and_bound_notification(str(thread_id), method, params)
         project_id = self._resolve_project_id(params)
         if not project_id:
             # Unresolved project_id would fan out to every open project tab.
@@ -195,6 +212,98 @@ class CodexChatManager:
             explicit_sessions=list(self._thread_sessions.get(str(thread_id), set())) if thread_id else None,
         )
 
+    @staticmethod
+    def _bounded_text(value: str, limit: int) -> str:
+        raw = value.encode("utf-8")
+        if len(raw) <= limit:
+            return value
+        marker = "\n[Portacode truncated oversized live output.]\n"
+        budget = max(limit - len(marker.encode("utf-8")), 0)
+        return raw[:budget].decode("utf-8", errors="ignore") + marker
+
+    def _materialize_and_bound_notification(
+        self, thread_id: str, method: str, params: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Bound UI command output and retain a reconnectable live snapshot."""
+        params = copy.deepcopy(params)
+        raw = params.get("item") if isinstance(params.get("item"), dict) else params
+        item_id = raw.get("id") or params.get("itemId") or params.get("id")
+        if not item_id or not method.startswith("item/"):
+            return params
+
+        item_id = str(item_id)
+        items = self._thread_live_items.setdefault(thread_id, {})
+        item = items.setdefault(item_id, {"id": item_id})
+        incoming_type = raw.get("type")
+        if incoming_type:
+            item["type"] = incoming_type
+        elif "commandExecution" in method:
+            item["type"] = "commandExecution"
+            item.setdefault("role", "tool")
+        elif "reasoning" in method:
+            item["type"] = "reasoning"
+            item.setdefault("role", "reasoning")
+        elif "agentMessage" in method or "message/delta" in method:
+            item["type"] = "agentMessage"
+            item.setdefault("role", "assistant")
+        for key in ("role", "command", "status"):
+            if raw.get(key) is not None:
+                item[key] = copy.deepcopy(raw[key])
+
+        is_command = "commandExecution" in method or item.get("type") == "commandExecution"
+        text_key = None
+        incoming = ""
+        if method == "item/commandExecution/outputDelta":
+            text_key, incoming = "output", raw.get("delta") or raw.get("output") or ""
+        elif method in {"item/agentMessage/delta", "item/message/delta"}:
+            text_key, incoming = "text", raw.get("delta") or raw.get("text") or ""
+        elif method in {"item/reasoning/textDelta", "item/reasoning/summaryTextDelta"}:
+            text_key, incoming = "reasoning", raw.get("delta") or raw.get("text") or ""
+        elif method in {"item/started", "item/completed"}:
+            if is_command:
+                text_key = "output"
+                incoming = raw.get("output") or (raw.get("commandExecution") or {}).get("output") or raw.get("aggregatedOutput") or ""
+            else:
+                incoming = raw.get("text") or ""
+                text_key = "text" if incoming else None
+
+        if text_key and isinstance(incoming, str):
+            limit = MAX_UI_COMMAND_OUTPUT_BYTES if text_key == "output" else MAX_LIVE_TEXT_BYTES
+            if method in {"item/started", "item/completed"}:
+                combined = incoming
+            else:
+                combined = str(item.get(text_key) or "") + incoming
+            bounded = self._bounded_text(combined, limit)
+            item[text_key] = bounded
+            # Forward only the portion that fits for deltas; completed items
+            # carry a bounded aggregate so the browser cannot restore the blob.
+            if method.endswith("/outputDelta") or method.endswith("/delta") or method.endswith("textDelta") or method.endswith("summaryTextDelta"):
+                previous = combined[:-len(incoming)] if incoming else combined
+                allowed = bounded[len(previous):] if bounded.startswith(previous) else ""
+                if "delta" in raw:
+                    raw["delta"] = allowed
+                elif text_key in raw:
+                    raw[text_key] = allowed
+            elif text_key == "output":
+                raw["output"] = bounded
+                raw.pop("aggregatedOutput", None)
+                if isinstance(raw.get("commandExecution"), dict):
+                    raw["commandExecution"]["output"] = bounded
+        while len(items) > MAX_LIVE_ITEMS_PER_THREAD:
+            oldest = next(iter(items))
+            if oldest == item_id and len(items) > 1:
+                oldest = next(key for key in items if key != item_id)
+            items.pop(oldest, None)
+        while sum(len(str(value).encode("utf-8")) for value in items.values()) > MAX_LIVE_SNAPSHOT_BYTES and len(items) > 1:
+            oldest = next(iter(items))
+            if oldest == item_id:
+                oldest = next(key for key in items if key != item_id)
+            items.pop(oldest, None)
+        return params
+
+    def live_items(self, thread_id: str) -> List[Dict[str, Any]]:
+        return copy.deepcopy(list(self._thread_live_items.get(str(thread_id), {}).values()))
+
     def _remember_thread_from_params(self, params: Dict[str, Any]) -> None:
         """Opportunistically map threadId → project when cwd is already known."""
         if not isinstance(params, dict):
@@ -356,6 +465,7 @@ async def _resume_thread_history(
     *,
     thread_id: str,
     cwd: Optional[str],
+    already_active: bool = False,
 ) -> tuple[Dict[str, Any], list, Optional[Dict[str, Any]]]:
     """Resume a thread without hydrating the full rollout in one giant payload.
 
@@ -366,11 +476,12 @@ async def _resume_thread_history(
     if cwd:
         resume_params["cwd"] = cwd
 
-    resume_result: Dict[str, Any] = {}
+    resume_result: Dict[str, Any] = {"thread": {"id": thread_id}}
     try:
-        resume_result = await manager.bridge.call(
-            "thread/resume", resume_params, timeout=120.0
-        )
+        if not already_active:
+            resume_result = await manager.bridge.call(
+                "thread/resume", resume_params, timeout=120.0
+            )
     except CodexAppServerError as exc:
         # Older Codex builds may not know excludeTurns — fall back carefully.
         message = str(exc).lower()
@@ -639,15 +750,23 @@ class CodexThreadResumeHandler(CodexAsyncHandler):
         manager.subscribe_thread(thread_id, message.get("source_client_session"))
 
         resume_result, items, active_turn = await _resume_thread_history(
-            manager, thread_id=thread_id, cwd=cwd
+            manager,
+            thread_id=thread_id,
+            cwd=cwd,
+            already_active=str(thread_id) in manager._thread_active_turn,
         )
         thread = _thread_from_result(resume_result)
+        if not active_turn:
+            known_turn_id = manager._thread_active_turn.get(str(thread_id))
+            if known_turn_id:
+                active_turn = {"id": known_turn_id, "status": "inProgress"}
 
         payload = {
             "event": "codex_thread_resumed",
             "threadId": thread_id,
             "thread": thread,
             "items": items,
+            "liveItems": manager.live_items(thread_id),
         }
         if active_turn:
             payload["activeTurn"] = active_turn

{portacode-1.5.18.dev0 → portacode-1.5.19.dev1}/portacode/connection/handlers/file_handlers.py

@@ -506,6 +506,60 @@ class FileRenameHandler(SyncHandler):
             raise RuntimeError(f"Failed to rename: {e}")
 
 
+class FileMoveCopyHandler(SyncHandler):
+    """Move or copy a file/folder into an existing directory."""
+
+    @property
+    def command_name(self) -> str:
+        return "file_move_copy"
+
+    def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        source_raw = message.get("source_path")
+        destination_raw = message.get("destination_path")
+        operation = message.get("operation", "move")
+        if not source_raw or not destination_raw:
+            raise ValueError("source_path and destination_path are required")
+        if operation not in ("move", "copy"):
+            raise ValueError("operation must be 'move' or 'copy'")
+
+        source = Path(source_raw).resolve()
+        destination_dir = Path(destination_raw).resolve()
+        if not source.exists():
+            raise ValueError(f"Source does not exist: {source_raw}")
+        if not destination_dir.is_dir():
+            raise ValueError(f"Destination is not a directory: {destination_raw}")
+
+        target = destination_dir / source.name
+        if target.exists():
+            raise ValueError(f"An item named '{source.name}' already exists in the destination")
+        if source.parent == destination_dir:
+            raise ValueError("The item is already in that folder")
+        if source.is_dir() and (destination_dir == source or source in destination_dir.parents):
+            raise ValueError("A folder cannot be moved or copied into itself")
+
+        try:
+            if operation == "move":
+                shutil.move(str(source), str(target))
+            elif source.is_dir():
+                shutil.copytree(source, target, copy_function=shutil.copy2)
+            else:
+                shutil.copy2(source, target)
+        except PermissionError as exc:
+            raise RuntimeError(f"Permission denied: {exc}") from exc
+        except OSError as exc:
+            raise RuntimeError(f"Failed to {operation}: {exc}") from exc
+
+        return {
+            "event": "file_move_copy_response",
+            "source_path": str(source),
+            "destination_path": str(destination_dir),
+            "target_path": str(target),
+            "operation": operation,
+            "is_directory": target.is_dir(),
+            "success": True,
+        }
+
+
 class FileSearchHandler(SyncHandler):
     """Handler for searching text within files under a root directory."""