portacode 1.4.35.dev0__tar.gz → 1.4.35.dev2__tar.gz

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

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

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

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.4.35.dev0'
-__version_tuple__ = version_tuple = (1, 4, 35, 'dev0')
+__version__ = version = '1.4.35.dev2'
+__version_tuple__ = version_tuple = (1, 4, 35, 'dev2')
 
 __commit_id__ = commit_id = None

{portacode-1.4.35.dev0 → portacode-1.4.35.dev2}/portacode/cli.py

@@ -24,7 +24,7 @@ from .keypair import (
 )
 from .pairing import PairingError, pair_device_with_code
 from .connection.client import ConnectionManager, run_until_interrupt
-from .updater import build_pip_install_command
+from .updater import build_pip_install_command, run_pip_install_command
 
 GATEWAY_URL = "wss://portacode.com/gateway"
 GATEWAY_ENV = "PORTACODE_GATEWAY"
@@ -638,8 +638,18 @@ def restart_command(method: str, verbose: bool) -> None:
 def set_version_command(version: str) -> None:
     """Install a specific Portacode version and restart the system service."""
     click.echo(f"Installing Portacode {version}…")
-    result = subprocess.run(
-        build_pip_install_command(version=version), capture_output=True, text=True
+    interactive_tty = sys.stdin.isatty() and sys.stdout.isatty()
+    if interactive_tty and os.geteuid() != 0:
+        click.echo(
+            click.style(
+                "[sudo] If required, Portacode will attempt passwordless sudo first and then prompt for your password.",
+                fg="yellow",
+            )
+        )
+    result = run_pip_install_command(
+        build_pip_install_command(version=version),
+        allow_sudo_fallback=True,
+        interactive_sudo=interactive_tty,
     )
     if result.returncode != 0:
         error_msg = (result.stderr or result.stdout or "").strip() or "unknown error"

{portacode-1.4.35.dev0 → portacode-1.4.35.dev2}/portacode/connection/handlers/automation_v2_handlers.py

@@ -36,6 +36,7 @@ EXPOSED_SERVICES_ENV_KEY = "PORTACODE_EXPOSED_SERVICES_JSON"
 WAIT_FOR_PLACEHOLDER_RE = re.compile(r"\[exposed:(\d{1,5})\]", flags=re.IGNORECASE)
 WAIT_FOR_STEP_INTERVAL_SECONDS = 3.0
 WAIT_FOR_REQUEST_TIMEOUT_SECONDS = 5.0
+WAIT_FOR_DEFAULT_TIMEOUT_SECONDS = 120.0
 
 
 def _trim_text(value: Any, max_chars: int = MAX_STDIO_CHARS) -> str:
@@ -321,10 +322,19 @@ class _AutomationRuntimeV2:
                 self._persist_state()
                 await self._notify_change(dict(state))
                 default_timeout = float(state.get("default_timeout_seconds") or DEFAULT_STEP_TIMEOUT_SECONDS)
-                timeout_seconds = _extract_step_timeout(step, default_timeout)
+                timeout_fallback = WAIT_FOR_DEFAULT_TIMEOUT_SECONDS if wait_for_target else default_timeout
+                timeout_seconds = _extract_step_timeout(step, timeout_fallback)
+                task_id_payload: Any = int(task_id) if str(task_id).isdigit() else str(task_id)
 
             if wait_for_target:
                 command_label = f"wait_for {wait_for_target}"
+                logger.info(
+                    "automation_v2 wait_for start task=%s step=%s target=%s timeout_s=%.1f",
+                    task_id,
+                    step_index,
+                    wait_for_target,
+                    timeout_seconds,
+                )
                 duration_start = time.monotonic()
                 wait_result = await self._run_wait_for_step(
                     target=wait_for_target,
@@ -391,6 +401,14 @@ class _AutomationRuntimeV2:
                         return
 
                     if timed_out or returncode != 0:
+                        logger.warning(
+                            "automation_v2 wait_for failed task=%s step=%s target=%s resolved_url=%s stderr=%s",
+                            task_id,
+                            step_index,
+                            wait_for_target,
+                            resolved_url,
+                            stderr_text,
+                        )
                         state["status"] = "failed"
                         state["current_step_status"] = "failed"
                         state["completed_at"] = time.time()
@@ -406,6 +424,14 @@ class _AutomationRuntimeV2:
                     state["state_seq"] = int(state.get("state_seq") or 0) + 1
                     self._persist_state()
                     await self._notify_change(dict(state))
+                logger.info(
+                    "automation_v2 wait_for success task=%s step=%s target=%s resolved_url=%s duration_s=%.3f",
+                    task_id,
+                    step_index,
+                    wait_for_target,
+                    resolved_url,
+                    duration_s,
+                )
                 continue
 
             start = time.monotonic()
@@ -648,6 +674,13 @@ class _AutomationRuntimeV2:
         automation_task_id: Any,
         automation_step_index: int,
     ) -> dict[str, Any]:
+        logger.info(
+            "automation_v2 wait_for polling begin task=%s step=%s target=%s timeout_s=%.1f",
+            automation_task_id,
+            automation_step_index,
+            target,
+            timeout_seconds,
+        )
         deadline = time.monotonic() + max(1.0, float(timeout_seconds))
         attempts = 0
         last_error = ""
@@ -658,9 +691,39 @@ class _AutomationRuntimeV2:
                 resolved_url = self._resolve_wait_for_url(target)
             except Exception as exc:
                 last_error = str(exc)
+                logger.warning(
+                    "automation_v2 wait_for resolve failed task=%s step=%s attempt=%s target=%s error=%s",
+                    automation_task_id,
+                    automation_step_index,
+                    attempts,
+                    target,
+                    last_error,
+                )
+                if self._event_sender is not None:
+                    try:
+                        await self._event_sender(
+                            {
+                                "event": "terminal_exec_output",
+                                "command": f"wait_for {target}",
+                                "stderr": (
+                                    f"wait_for attempt={attempts} resolve_failed error={last_error}\n"
+                                ),
+                                "automation_task_id": automation_task_id,
+                                "automation_step_index": automation_step_index,
+                            }
+                        )
+                    except Exception:
+                        logger.exception("automation_v2: failed to emit terminal_exec_output")
                 await asyncio.sleep(WAIT_FOR_STEP_INTERVAL_SECONDS)
                 continue
 
+            logger.info(
+                "automation_v2 wait_for probe task=%s step=%s attempt=%s url=%s",
+                automation_task_id,
+                automation_step_index,
+                attempts,
+                resolved_url,
+            )
             ok, status, error = await asyncio.to_thread(self._probe_http_url, resolved_url)
             if ok:
                 message = (
@@ -668,6 +731,14 @@ class _AutomationRuntimeV2:
                     if status is not None
                     else f"wait_for success url={resolved_url} attempts={attempts}"
                 )
+                logger.info(
+                    "automation_v2 wait_for probe succeeded task=%s step=%s attempt=%s url=%s status=%s",
+                    automation_task_id,
+                    automation_step_index,
+                    attempts,
+                    resolved_url,
+                    status,
+                )
                 if self._event_sender is not None:
                     try:
                         await self._event_sender(
@@ -689,8 +760,43 @@ class _AutomationRuntimeV2:
                     "resolved_url": resolved_url,
                 }
             last_error = error or (f"http_status={status}" if status is not None else "request failed")
+            logger.info(
+                "automation_v2 wait_for probe not-ready task=%s step=%s attempt=%s url=%s status=%s error=%s",
+                automation_task_id,
+                automation_step_index,
+                attempts,
+                resolved_url,
+                status,
+                last_error,
+            )
+            if self._event_sender is not None:
+                try:
+                    await self._event_sender(
+                        {
+                            "event": "terminal_exec_output",
+                            "command": f"wait_for {target}",
+                            "stderr": (
+                                f"wait_for attempt={attempts} url={resolved_url} "
+                                f"status={status if status is not None else 'n/a'} "
+                                f"error={last_error}\n"
+                            ),
+                            "automation_task_id": automation_task_id,
+                            "automation_step_index": automation_step_index,
+                        }
+                    )
+                except Exception:
+                    logger.exception("automation_v2: failed to emit terminal_exec_output")
             await asyncio.sleep(WAIT_FOR_STEP_INTERVAL_SECONDS)
 
+        logger.warning(
+            "automation_v2 wait_for timeout task=%s step=%s target=%s resolved_url=%s attempts=%s last_error=%s",
+            automation_task_id,
+            automation_step_index,
+            target,
+            resolved_url,
+            attempts,
+            last_error,
+        )
         return {
             "returncode": 1,
             "stdout": "",

{portacode-1.4.35.dev0 → portacode-1.4.35.dev2}/portacode/connection/handlers/update_handler.py

@@ -1,10 +1,9 @@
 """Update handler for Portacode CLI."""
 
 import logging
-import subprocess
 from typing import Any, Dict, Optional
 
-from portacode.updater import build_pip_install_command
+from portacode.updater import build_pip_install_command, run_pip_install_command
 from .base import AsyncHandler
 
 logger = logging.getLogger(__name__)
@@ -22,7 +21,11 @@ class UpdatePortacodeHandler(AsyncHandler):
         try:
             logger.info("Starting Portacode CLI update...")
             pip_cmd = build_pip_install_command()
-            result = subprocess.run(pip_cmd, capture_output=True, text=True, timeout=120)
+            result = run_pip_install_command(
+                pip_cmd,
+                allow_sudo_fallback=True,
+                interactive_sudo=False,
+            )
 
             if result.returncode != 0:
                 error_msg = result.stderr.strip() or result.stdout.strip()
@@ -50,12 +53,6 @@ class UpdatePortacodeHandler(AsyncHandler):
             request_restart(method="auto", in_service=True)
             return None
 
-        except subprocess.TimeoutExpired:
-            return {
-                "event": "update_portacode_response",
-                "success": False,
-                "error": "Update timed out after 120 seconds",
-            }
         except Exception as e:
             logger.exception("Update failed with exception")
             return {

portacode-1.4.35.dev2/portacode/test_updater.py

@@ -0,0 +1,100 @@
+from unittest import TestCase
+from unittest.mock import patch
+import subprocess
+
+from portacode.updater import build_pip_install_command, run_pip_install_command
+
+
+class UpdaterCommandTests(TestCase):
+    def _cp(self, returncode: int, stdout: str = "", stderr: str = "") -> subprocess.CompletedProcess[str]:
+        return subprocess.CompletedProcess(args=["cmd"], returncode=returncode, stdout=stdout, stderr=stderr)
+
+    @patch("portacode.updater._running_in_virtualenv", return_value=True)
+    def test_venv_omits_user_flag_for_non_root(self, _mock_venv):
+        with patch("portacode.updater.sys.executable", "/opt/portacode-venv/bin/python"):
+            with patch("portacode.updater.os.geteuid", return_value=1000):
+                cmd = build_pip_install_command(version="1.4.34.dev7")
+
+        self.assertEqual(
+            cmd,
+            [
+                "/opt/portacode-venv/bin/python",
+                "-m",
+                "pip",
+                "install",
+                "--upgrade",
+                "portacode==1.4.34.dev7",
+            ],
+        )
+
+    @patch("portacode.updater._running_in_virtualenv", return_value=False)
+    def test_non_root_outside_venv_uses_user_flag(self, _mock_venv):
+        with patch("portacode.updater.sys.executable", "/usr/bin/python3"):
+            with patch("portacode.updater.os.geteuid", return_value=1000):
+                cmd = build_pip_install_command(version="1.4.34.dev7")
+
+        self.assertEqual(cmd[-1], "--user")
+        self.assertEqual(cmd[:6], ["/usr/bin/python3", "-m", "pip", "install", "--upgrade", "portacode==1.4.34.dev7"])
+
+    @patch("portacode.updater._running_in_virtualenv", return_value=False)
+    @patch("portacode.updater.shutil.which", return_value="/usr/bin/sudo")
+    def test_root_with_sudo_user_outside_venv_switches_to_invoking_user(self, _mock_which, _mock_venv):
+        with patch("portacode.updater.sys.executable", "/usr/bin/python3"):
+            with patch("portacode.updater.os.geteuid", return_value=0):
+                with patch.dict("portacode.updater.os.environ", {"SUDO_USER": "ubuntu"}, clear=False):
+                    cmd = build_pip_install_command(version="1.4.34.dev7")
+
+        self.assertEqual(cmd[:4], ["sudo", "-u", "ubuntu", "-H"])
+        self.assertEqual(cmd[-1], "--user")
+
+    @patch("portacode.updater.shutil.which", return_value="/usr/bin/sudo")
+    @patch("portacode.updater.os.geteuid", return_value=1000)
+    @patch("portacode.updater.subprocess.run")
+    def test_run_install_uses_sudo_n_on_permission_error(self, mock_run, _mock_euid, _mock_which):
+        mock_run.side_effect = [
+            self._cp(1, stderr="Permission denied: '/opt/portacode-venv/bin/portacode'"),
+            self._cp(0, stdout="ok"),
+        ]
+        result = run_pip_install_command(
+            ["/opt/portacode-venv/bin/python", "-m", "pip", "install", "--upgrade", "portacode==1.4.35.dev0"],
+            allow_sudo_fallback=True,
+            interactive_sudo=False,
+        )
+
+        self.assertEqual(result.returncode, 0)
+        self.assertEqual(mock_run.call_count, 2)
+        self.assertEqual(mock_run.call_args_list[1][0][0][:2], ["sudo", "-n"])
+
+    @patch("portacode.updater.shutil.which", return_value="/usr/bin/sudo")
+    @patch("portacode.updater.os.geteuid", return_value=1000)
+    @patch("portacode.updater.subprocess.run")
+    def test_run_install_falls_back_to_interactive_sudo_prompt(self, mock_run, _mock_euid, _mock_which):
+        mock_run.side_effect = [
+            self._cp(1, stderr="Permission denied"),
+            self._cp(1, stderr="sudo: a password is required"),
+            self._cp(0, stdout="ok"),
+        ]
+        result = run_pip_install_command(
+            ["/opt/portacode-venv/bin/python", "-m", "pip", "install", "--upgrade", "portacode==1.4.35.dev0"],
+            allow_sudo_fallback=True,
+            interactive_sudo=True,
+        )
+
+        self.assertEqual(result.returncode, 0)
+        self.assertEqual(mock_run.call_count, 3)
+        self.assertEqual(mock_run.call_args_list[1][0][0][:2], ["sudo", "-n"])
+        self.assertEqual(mock_run.call_args_list[2][0][0][0], "sudo")
+
+    @patch("portacode.updater.shutil.which", return_value="/usr/bin/sudo")
+    @patch("portacode.updater.os.geteuid", return_value=1000)
+    @patch("portacode.updater.subprocess.run")
+    def test_run_install_does_not_use_sudo_when_not_permission_issue(self, mock_run, _mock_euid, _mock_which):
+        mock_run.return_value = self._cp(1, stderr="No matching distribution found")
+        result = run_pip_install_command(
+            ["/opt/portacode-venv/bin/python", "-m", "pip", "install", "--upgrade", "portacode==bad"],
+            allow_sudo_fallback=True,
+            interactive_sudo=True,
+        )
+
+        self.assertEqual(result.returncode, 1)
+        mock_run.assert_called_once()

{portacode-1.4.35.dev0 → portacode-1.4.35.dev2}/portacode/updater.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import os
 import sys
 import shutil
+import subprocess
 from typing import List, Optional, Sequence
 
 
@@ -16,6 +17,53 @@ def _running_in_virtualenv() -> bool:
     return sys.prefix != base_prefix
 
 
+def _is_permission_error(output: str) -> bool:
+    text = (output or "").lower()
+    return "permission denied" in text or "errno 13" in text
+
+
+def _sudo_requires_password(output: str) -> bool:
+    text = (output or "").lower()
+    return ("sudo:" in text and "password" in text) or "a password is required" in text
+
+
+def run_pip_install_command(
+    cmd: Sequence[str],
+    *,
+    allow_sudo_fallback: bool = False,
+    interactive_sudo: bool = False,
+) -> subprocess.CompletedProcess[str]:
+    """Run a pip install command, with optional sudo fallback on permission errors."""
+    result = subprocess.run(list(cmd), capture_output=True, text=True)
+    if result.returncode == 0:
+        return result
+
+    if not allow_sudo_fallback:
+        return result
+
+    if os.geteuid() == 0 or not shutil.which("sudo"):
+        return result
+
+    combined = f"{result.stderr or ''}\n{result.stdout or ''}"
+    if not _is_permission_error(combined):
+        return result
+
+    sudo_non_interactive = subprocess.run(
+        ["sudo", "-n", *cmd], capture_output=True, text=True
+    )
+    if sudo_non_interactive.returncode == 0:
+        return sudo_non_interactive
+
+    if not interactive_sudo:
+        return sudo_non_interactive
+
+    sudo_output = f"{sudo_non_interactive.stderr or ''}\n{sudo_non_interactive.stdout or ''}"
+    if _sudo_requires_password(sudo_output):
+        return subprocess.run(["sudo", *cmd], capture_output=True, text=True)
+
+    return sudo_non_interactive
+
+
 def build_pip_install_command(
     package: str = "portacode",
     version: Optional[str] = None,

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

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

portacode-1.4.35.dev0/portacode/test_updater.py

@@ -1,44 +0,0 @@
-from unittest import TestCase
-from unittest.mock import patch
-
-from portacode.updater import build_pip_install_command
-
-
-class UpdaterCommandTests(TestCase):
-    @patch("portacode.updater._running_in_virtualenv", return_value=True)
-    def test_venv_omits_user_flag_for_non_root(self, _mock_venv):
-        with patch("portacode.updater.sys.executable", "/opt/portacode-venv/bin/python"):
-            with patch("portacode.updater.os.geteuid", return_value=1000):
-                cmd = build_pip_install_command(version="1.4.34.dev7")
-
-        self.assertEqual(
-            cmd,
-            [
-                "/opt/portacode-venv/bin/python",
-                "-m",
-                "pip",
-                "install",
-                "--upgrade",
-                "portacode==1.4.34.dev7",
-            ],
-        )
-
-    @patch("portacode.updater._running_in_virtualenv", return_value=False)
-    def test_non_root_outside_venv_uses_user_flag(self, _mock_venv):
-        with patch("portacode.updater.sys.executable", "/usr/bin/python3"):
-            with patch("portacode.updater.os.geteuid", return_value=1000):
-                cmd = build_pip_install_command(version="1.4.34.dev7")
-
-        self.assertEqual(cmd[-1], "--user")
-        self.assertEqual(cmd[:6], ["/usr/bin/python3", "-m", "pip", "install", "--upgrade", "portacode==1.4.34.dev7"])
-
-    @patch("portacode.updater._running_in_virtualenv", return_value=False)
-    @patch("portacode.updater.shutil.which", return_value="/usr/bin/sudo")
-    def test_root_with_sudo_user_outside_venv_switches_to_invoking_user(self, _mock_which, _mock_venv):
-        with patch("portacode.updater.sys.executable", "/usr/bin/python3"):
-            with patch("portacode.updater.os.geteuid", return_value=0):
-                with patch.dict("portacode.updater.os.environ", {"SUDO_USER": "ubuntu"}, clear=False):
-                    cmd = build_pip_install_command(version="1.4.34.dev7")
-
-        self.assertEqual(cmd[:4], ["sudo", "-u", "ubuntu", "-H"])
-        self.assertEqual(cmd[-1], "--user")