portacode 1.5.32.dev2__tar.gz → 1.5.33.dev0__tar.gz

{portacode-1.5.32.dev2 → portacode-1.5.33.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.5.32.dev2
+Version: 1.5.33.dev0
 Summary: Connect real machines to the Portacode AI development environment
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian

{portacode-1.5.32.dev2 → portacode-1.5.33.dev0}/portacode/_version.py

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

{portacode-1.5.32.dev2 → portacode-1.5.33.dev0}/portacode/connection/handlers/cloudflare_forwarding.py

@@ -11,6 +11,10 @@ import subprocess
 import threading
 import tempfile
 import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 from urllib.parse import urlparse
@@ -29,6 +33,7 @@ from .proxmox_infra import (
     _resolve_vmid_for_device_in_proxmox,
 )
 from portacode.tunneling.forwarding_state import load_forwarding_state, persist_forwarding_state
+from portacode.tunneling.get_domain import extract_token_json
 from portacode.tunneling.state import default_config_path, load_state
 from portacode.tunneling.privileged import write_text
 from portacode.tunneling.service_install import restart_service
@@ -223,10 +228,10 @@ def _resolve_service_endpoint(
     if device_id in cache:
         ip = cache[device_id]
     else:
-        vmid = _resolve_device_vmid(device_id, proxmox, node)
         try:
+            vmid = _resolve_device_vmid(device_id, proxmox, node)
             ip = _find_container_ip(proxmox, node, vmid, leases)
-        except RuntimeError:
+        except (_DeviceLookupError, RuntimeError):
             ip = str(parsed.get("resolved_ip") or "").strip()
             if not ip:
                 raise
@@ -353,6 +358,7 @@ def _write_cloudflared_config(state: Dict[str, Any], entries: List[Dict[str, Any
 
 
 def _route_dns(hostnames: List[str], tunnel_name: str) -> None:
+    """Compatibility fallback for nodes whose API credential cannot edit DNS."""
     seen = set()
     for hostname in hostnames:
         if hostname in seen:
@@ -379,6 +385,141 @@ def _route_dns(hostnames: List[str], tunnel_name: str) -> None:
             ) from exc
 
 
+def _cloudflare_api_request(
+    method: str,
+    path: str,
+    *,
+    api_token: str,
+    payload: Dict[str, Any] | None = None,
+) -> Any:
+    body = json.dumps(payload).encode("utf-8") if payload is not None else None
+    request = urllib.request.Request(
+        f"https://api.cloudflare.com/client/v4{path}",
+        data=body,
+        method=method,
+        headers={
+            "Authorization": f"Bearer {api_token}",
+            "Content-Type": "application/json",
+        },
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=10) as response:
+            response_data = json.loads(response.read().decode("utf-8"))
+    except (OSError, urllib.error.URLError, json.JSONDecodeError) as exc:
+        raise RuntimeError(f"Cloudflare DNS API request failed: {exc}") from exc
+    if not response_data.get("success"):
+        errors = response_data.get("errors") or []
+        message = errors[0].get("message") if errors else "unknown API error"
+        raise RuntimeError(f"Cloudflare DNS API error: {message}")
+    return response_data.get("result")
+
+
+def _upsert_tunnel_dns_record(
+    hostname: str,
+    *,
+    zone_id: str,
+    api_token: str,
+    tunnel_id: str,
+) -> str:
+    query = urllib.parse.urlencode({"name": hostname, "per_page": 100})
+    records = _cloudflare_api_request(
+        "GET",
+        f"/zones/{zone_id}/dns_records?{query}",
+        api_token=api_token,
+    )
+    existing = records[0] if isinstance(records, list) and records else None
+    desired = {
+        "type": "CNAME",
+        "name": hostname,
+        "content": f"{tunnel_id}.cfargotunnel.com",
+        "proxied": True,
+        "ttl": 1,
+    }
+    if existing:
+        matches = (
+            str(existing.get("type") or "").upper() == desired["type"]
+            and str(existing.get("content") or "").rstrip(".").lower()
+            == desired["content"].lower()
+            and bool(existing.get("proxied"))
+        )
+        if matches:
+            return "unchanged"
+        record_id = str(existing.get("id") or "").strip()
+        if not record_id:
+            raise RuntimeError(f"Cloudflare DNS record for {hostname!r} has no ID")
+        _cloudflare_api_request(
+            "PUT",
+            f"/zones/{zone_id}/dns_records/{record_id}",
+            api_token=api_token,
+            payload=desired,
+        )
+        return "updated"
+    _cloudflare_api_request(
+        "POST",
+        f"/zones/{zone_id}/dns_records",
+        api_token=api_token,
+        payload=desired,
+    )
+    return "created"
+
+
+def _route_dns_via_api(hostnames: List[str], tunnel_state: Dict[str, Any]) -> None:
+    cert_path = str(tunnel_state.get("cert_path") or "").strip()
+    tunnel_id = str(tunnel_state.get("tunnel_id") or "").strip()
+    if not cert_path or not tunnel_id:
+        raise RuntimeError("Cloudflare certificate or tunnel ID missing from state")
+    credential = extract_token_json(cert_path)
+    zone_id = str(credential.get("zoneID") or "").strip()
+    api_token = str(credential.get("apiToken") or "").strip()
+    if not zone_id or not api_token:
+        raise RuntimeError("Cloudflare zone/API credential missing from certificate")
+
+    unique_hostnames = list(dict.fromkeys(hostnames))
+    failures: List[str] = []
+    with ThreadPoolExecutor(max_workers=min(4, len(unique_hostnames))) as executor:
+        futures = {
+            executor.submit(
+                _upsert_tunnel_dns_record,
+                hostname,
+                zone_id=zone_id,
+                api_token=api_token,
+                tunnel_id=tunnel_id,
+            ): hostname
+            for hostname in unique_hostnames
+        }
+        for future in as_completed(futures):
+            hostname = futures[future]
+            try:
+                action = future.result()
+                logger.info("Cloudflare DNS API hostname=%s action=%s", hostname, action)
+            except Exception as exc:
+                failures.append(f"{hostname}: {exc}")
+    if failures:
+        raise RuntimeError("; ".join(failures))
+
+
+def _route_new_dns(hostnames: List[str], tunnel_state: Dict[str, Any]) -> None:
+    if not hostnames:
+        return
+    started = time.monotonic()
+    try:
+        _route_dns_via_api(hostnames, tunnel_state)
+        method = "api"
+    except Exception as exc:
+        logger.warning(
+            "Direct Cloudflare DNS update failed; using cloudflared fallback: %s",
+            exc,
+        )
+        _route_dns(hostnames, str(tunnel_state.get("tunnel_name") or ""))
+        method = "cloudflared"
+    logger.info(
+        "Expose ports timing stage=route_dns_all method=%s hostname_count=%s elapsed_s=%.3f",
+        method,
+        len(hostnames),
+        time.monotonic() - started,
+    )
+
+
 def _reload_cloudflared_service() -> None:
     # Restart via init-system aware logic; sudo/root handled inside.
     started = time.monotonic()
@@ -412,21 +553,6 @@ def _sanitize_rules(rules: List[Dict[str, Any]]) -> List[Dict[str, str]]:
     return sanitized
 
 
-def _node_device_id(tunnel_state: Dict[str, Any]) -> str:
-    explicit = str(tunnel_state.get("node_device_id") or "").strip()
-    if explicit.isdigit():
-        return explicit
-    match = re.fullmatch(r"portacode-proxmox-(\d+)", str(tunnel_state.get("tunnel_name") or ""))
-    if not match:
-        raise RuntimeError("Unable to determine node device ID for wildcard forwarding")
-    return match.group(1)
-
-
-def _wildcard_hostname(tunnel_state: Dict[str, Any]) -> str:
-    domain = str(tunnel_state.get("domain") or "").strip().lower().rstrip(".")
-    return f"*.{_node_device_id(tunnel_state)}.{domain}"
-
-
 def _apply_and_persist_forwarding_rules(
     rules: List[Dict[str, Any]],
     *,
@@ -455,24 +581,57 @@ def _apply_and_persist_forwarding_rules(
     started = time.monotonic()
     entries = _build_ingress_entries(rules, proxmox, node)
     _timed_stage(operation_id, "build_ingress_entries", started, rule_count=len(rules))
-    started = time.monotonic()
-    _write_cloudflared_config(tunnel_state, entries)
-    _timed_stage(operation_id, "write_cloudflared_config", started, entry_count=len(entries))
     forwarding_state = load_forwarding_state()
-    desired_wildcard = _wildcard_hostname(tunnel_state)
-    provisioned_wildcard = str(forwarding_state.get("wildcard_dns_hostname") or "")
-    hostnames = [] if provisioned_wildcard == desired_wildcard else [desired_wildcard]
-    if hostnames:
+    existing_hostnames = {
+        str(rule.get("hostname") or "").strip().lower().rstrip(".")
+        for rule in forwarding_state.get("rules", [])
+        if isinstance(rule, dict)
+    }
+    hostnames = [
+        entry["hostname"]
+        for entry in entries
+        if entry.get("hostname")
+        and str(entry["hostname"]).strip().lower().rstrip(".") not in existing_hostnames
+    ]
+
+    cfg = tunnel_state.get("config_path")
+    config_path = Path(str(cfg)) if cfg else Path(default_config_path())
+    try:
+        previous_config = config_path.read_bytes()
+        previous_mode = config_path.stat().st_mode & 0o777
+    except OSError:
+        previous_config = None
+        previous_mode = 0o644
+
+    try:
         started = time.monotonic()
-        _route_dns(hostnames, tunnel_name)
-        _timed_stage(operation_id, "route_dns_all", started, hostname_count=len(hostnames))
-    started = time.monotonic()
-    _reload_cloudflared_service()
-    _timed_stage(operation_id, "reload_cloudflared_call", started)
+        _write_cloudflared_config(tunnel_state, entries)
+        _timed_stage(operation_id, "write_cloudflared_config", started, entry_count=len(entries))
+        _route_new_dns(hostnames, tunnel_state)
+        started = time.monotonic()
+        _reload_cloudflared_service()
+        _timed_stage(operation_id, "reload_cloudflared_call", started)
+    except Exception:
+        logger.exception(
+            "Forwarding update failed; restoring previous cloudflared config operation_id=%s",
+            operation_id,
+        )
+        if previous_config is not None:
+            try:
+                write_text(
+                    config_path,
+                    previous_config.decode("utf-8"),
+                    mode=previous_mode,
+                )
+                _reload_cloudflared_service()
+            except Exception:
+                logger.exception(
+                    "Failed to restore previous cloudflared config operation_id=%s",
+                    operation_id,
+                )
+        raise
     started = time.monotonic()
-    state = persist_forwarding_state(
-        rules, metadata={"wildcard_dns_hostname": desired_wildcard}
-    )
+    state = persist_forwarding_state(rules)
     _timed_stage(operation_id, "persist_forwarding_state", started, rule_count=len(rules))
     _timed_stage(operation_id, "apply_total", total_started, rule_count=len(rules))
     return {
@@ -499,11 +658,16 @@ def _new_container_hostname(
     index: int,
     tunnel_state: Dict[str, Any],
 ) -> str:
-    node_id = _node_device_id(tunnel_state)
     domain = str(tunnel_state.get("domain") or "").strip().lower().rstrip(".")
     protocol_suffix = "-https" if protocol == "https" else ""
     label = device_id if index == 0 else f"{device_id}-{port}{protocol_suffix}"
-    return f"{label}.{node_id}.{domain}"
+    return f"{label}.{domain}"
+
+
+def _is_single_level_hostname(hostname: str, domain: str) -> bool:
+    normalized = str(hostname or "").strip().lower().rstrip(".")
+    suffix = f".{domain}"
+    return normalized.endswith(suffix) and "." not in normalized[: -len(suffix)]
 
 
 def _normalize_container_rule_specs(
@@ -842,7 +1006,8 @@ def set_container_forwarding_rules(
             parsed = rule.get("parsed") or {}
             if parsed.get("type") != "device":
                 continue
-            reusable_hostnames[(int(parsed["port"]), str(parsed["scheme"]))] = rule["hostname"]
+            if _is_single_level_hostname(rule["hostname"], domain):
+                reusable_hostnames[(int(parsed["port"]), str(parsed["scheme"]))] = rule["hostname"]
             recorded_target_ip = str(rule.get("resolved_ip") or recorded_target_ip)
         new_rules: List[Dict[str, Any]] = []
         exposed_ports: List[Dict[str, Any]] = []

portacode-1.5.33.dev0/portacode/connection/handlers/test_cloudflare_forwarding.py

@@ -0,0 +1,262 @@
+import json
+import tempfile
+from pathlib import Path
+from unittest import TestCase
+from unittest.mock import patch
+
+from portacode.connection.handlers.cloudflare_forwarding import (
+    EXPOSED_SERVICES_JSON_PATH,
+    _build_exposed_services_env_map,
+    _sync_exposed_services_into_container,
+    _build_ingress_entries,
+    _new_container_hostname,
+    _apply_and_persist_forwarding_rules,
+    _route_new_dns,
+    _upsert_tunnel_dns_record,
+    set_container_forwarding_rules,
+)
+
+
+class CloudflareForwardingEnvTests(TestCase):
+    def test_new_container_hostname_stays_at_certificate_covered_level(self):
+        state = {"domain": "example.com", "tunnel_name": "portacode-proxmox-6"}
+        self.assertEqual(_new_container_hostname("598", 3001, "http", 0, state), "598.example.com")
+        self.assertEqual(_new_container_hostname("598", 8000, "http", 1, state), "598-8000.example.com")
+        self.assertEqual(
+            _new_container_hostname("598", 8000, "https", 1, state),
+            "598-8000-https.example.com",
+        )
+
+    @patch("portacode.connection.handlers.cloudflare_forwarding._load_leases", return_value=[])
+    @patch("portacode.connection.handlers.cloudflare_forwarding._resolve_device_vmid", return_value=141)
+    @patch("portacode.connection.handlers.cloudflare_forwarding._find_container_ip", side_effect=RuntimeError("offline"))
+    def test_ingress_uses_recorded_ip_when_container_is_offline(
+        self, _mock_find_ip, _mock_vmid, _mock_leases
+    ):
+        rules = [{
+            "hostname": "598.6.example.com",
+            "destination": "http://[598]:3001",
+            "parsed": {"type": "device", "device_id": "598", "scheme": "http", "port": 3001, "path": ""},
+            "resolved_ip": "10.77.0.25",
+        }]
+        entries = _build_ingress_entries(rules, object(), "pve2")
+        self.assertEqual(entries[0]["service"], "http://10.77.0.25:3001")
+
+    @patch("portacode.connection.handlers.cloudflare_forwarding._load_leases", return_value=[])
+    @patch(
+        "portacode.connection.handlers.cloudflare_forwarding._resolve_device_vmid",
+        side_effect=RuntimeError("missing stale mapping"),
+    )
+    def test_ingress_uses_recorded_ip_when_neighbor_mapping_is_missing(
+        self, _mock_vmid, _mock_leases
+    ):
+        rules = [{
+            "hostname": "900.example.com",
+            "destination": "http://[900]:8000",
+            "parsed": {"type": "device", "device_id": "900", "scheme": "http", "port": 8000, "path": ""},
+            "resolved_ip": "10.77.0.90",
+        }]
+
+        entries = _build_ingress_entries(rules, object(), "pve2")
+
+        self.assertEqual(entries[0]["service"], "http://10.77.0.90:8000")
+
+    @patch("portacode.connection.handlers.cloudflare_forwarding.persist_forwarding_state", return_value={"updated_at": "now"})
+    @patch("portacode.connection.handlers.cloudflare_forwarding._reload_cloudflared_service")
+    @patch("portacode.connection.handlers.cloudflare_forwarding._route_new_dns")
+    @patch("portacode.connection.handlers.cloudflare_forwarding._write_cloudflared_config")
+    @patch("portacode.connection.handlers.cloudflare_forwarding._build_ingress_entries")
+    @patch("portacode.connection.handlers.cloudflare_forwarding.load_forwarding_state")
+    def test_only_new_hostnames_are_routed(
+        self, mock_load, mock_build, _mock_write, mock_route, _mock_reload, _mock_persist
+    ):
+        tunnel = {"domain": "example.com", "tunnel_name": "portacode-proxmox-6"}
+        mock_load.return_value = {
+            "rules": [{"hostname": "other-user.example.com", "destination": "http://[10]:80"}]
+        }
+        mock_build.return_value = [
+            {"hostname": "other-user.example.com", "service": "http://10.0.0.1:80"},
+            {"hostname": "new-user.example.com", "service": "http://10.0.0.2:80"},
+        ]
+
+        _apply_and_persist_forwarding_rules([], tunnel_state=tunnel)
+
+        mock_route.assert_called_once_with(["new-user.example.com"], tunnel)
+
+    @patch("portacode.connection.handlers.cloudflare_forwarding._cloudflare_api_request")
+    def test_dns_upsert_reuses_matching_record(self, mock_request):
+        mock_request.return_value = [
+            {
+                "id": "record-1",
+                "type": "CNAME",
+                "content": "tunnel-1.cfargotunnel.com",
+                "proxied": True,
+            }
+        ]
+
+        action = _upsert_tunnel_dns_record(
+            "598.example.com",
+            zone_id="zone-1",
+            api_token="secret",
+            tunnel_id="tunnel-1",
+        )
+
+        self.assertEqual(action, "unchanged")
+        self.assertEqual(mock_request.call_count, 1)
+
+    @patch("portacode.connection.handlers.cloudflare_forwarding._cloudflare_api_request")
+    def test_dns_upsert_updates_conflicting_record(self, mock_request):
+        mock_request.side_effect = [[{"id": "record-1", "type": "A", "content": "192.0.2.1"}], {}]
+
+        action = _upsert_tunnel_dns_record(
+            "598.example.com",
+            zone_id="zone-1",
+            api_token="secret",
+            tunnel_id="tunnel-1",
+        )
+
+        self.assertEqual(action, "updated")
+        self.assertEqual(mock_request.call_args_list[1].args[:2], ("PUT", "/zones/zone-1/dns_records/record-1"))
+
+    @patch("portacode.connection.handlers.cloudflare_forwarding._route_dns")
+    @patch("portacode.connection.handlers.cloudflare_forwarding._route_dns_via_api", side_effect=RuntimeError("no API"))
+    def test_dns_api_failure_falls_back_to_cloudflared(self, _mock_api, mock_cli):
+        tunnel = {"tunnel_name": "portacode-proxmox-6"}
+
+        _route_new_dns(["598.example.com"], tunnel)
+
+        mock_cli.assert_called_once_with(["598.example.com"], "portacode-proxmox-6")
+
+    @patch("portacode.connection.handlers.cloudflare_forwarding._sync_exposed_services_into_container")
+    @patch("portacode.connection.handlers.cloudflare_forwarding._get_node_from_config", return_value="pve2")
+    @patch("portacode.connection.handlers.cloudflare_forwarding._connect_proxmox", return_value=object())
+    @patch("portacode.connection.handlers.cloudflare_forwarding._ensure_infra_configured", return_value={})
+    @patch("portacode.connection.handlers.cloudflare_forwarding._apply_and_persist_forwarding_rules")
+    @patch("portacode.connection.handlers.cloudflare_forwarding.load_forwarding_state")
+    @patch("portacode.connection.handlers.cloudflare_forwarding._load_tunnel_state")
+    def test_container_update_preserves_neighbor_and_migrates_nested_hostname(
+        self,
+        mock_tunnel,
+        mock_load,
+        mock_apply,
+        _mock_infra,
+        _mock_connect,
+        _mock_node,
+        _mock_sync,
+    ):
+        mock_tunnel.return_value = {
+            "domain": "example.com",
+            "tunnel_name": "portacode-proxmox-6",
+        }
+        neighbor = {
+            "hostname": "900.example.com",
+            "destination": "http://[900]:8000",
+            "parsed": {
+                "type": "device",
+                "device_id": "900",
+                "scheme": "http",
+                "port": 8000,
+                "path": "",
+            },
+            "resolved_ip": "10.0.0.90",
+        }
+        old_target = {
+            "hostname": "598.6.example.com",
+            "destination": "http://[598]:3001",
+            "parsed": {
+                "type": "device",
+                "device_id": "598",
+                "scheme": "http",
+                "port": 3001,
+                "path": "",
+            },
+            "resolved_ip": "10.0.0.58",
+        }
+        mock_load.return_value = {"rules": [neighbor, old_target]}
+        mock_apply.side_effect = lambda rules, **_kwargs: {
+            "rules": rules,
+            "updated_at": "now",
+        }
+
+        result = set_container_forwarding_rules(
+            "598",
+            [{"subdomain": "598", "port": 3001, "protocol": "http"}],
+        )
+
+        applied_rules = mock_apply.call_args.args[0]
+        self.assertEqual(applied_rules[0], neighbor)
+        self.assertEqual(applied_rules[1]["hostname"], "598.example.com")
+        self.assertEqual(applied_rules[1]["resolved_ip"], "10.0.0.58")
+        self.assertEqual(result["exposed_ports"][0]["hostname"], "598.example.com")
+
+    @patch("portacode.connection.handlers.cloudflare_forwarding.persist_forwarding_state")
+    @patch("portacode.connection.handlers.cloudflare_forwarding._reload_cloudflared_service")
+    @patch("portacode.connection.handlers.cloudflare_forwarding._route_new_dns", side_effect=RuntimeError("DNS failed"))
+    @patch("portacode.connection.handlers.cloudflare_forwarding._build_ingress_entries")
+    @patch("portacode.connection.handlers.cloudflare_forwarding.load_forwarding_state", return_value={"rules": []})
+    def test_failed_update_restores_previous_config(
+        self, _mock_load, mock_build, _mock_route, mock_reload, mock_persist
+    ):
+        with tempfile.TemporaryDirectory() as tmp:
+            config_path = Path(tmp) / "config.yml"
+            config_path.write_text("previous config\n", encoding="utf-8")
+            mock_build.return_value = [{"hostname": "new.example.com", "service": "http://10.0.0.2"}]
+            tunnel = {
+                "domain": "example.com",
+                "tunnel_name": "portacode-proxmox-6",
+                "tunnel_id": "tunnel-1",
+                "credentials_file": str(config_path),
+                "config_path": str(config_path),
+            }
+
+            with self.assertRaisesRegex(RuntimeError, "DNS failed"):
+                _apply_and_persist_forwarding_rules([], tunnel_state=tunnel)
+
+            self.assertEqual(config_path.read_text(encoding="utf-8"), "previous config\n")
+            mock_reload.assert_called_once()
+            mock_persist.assert_not_called()
+
+    def test_build_exposed_services_env_map_adds_indexed_public_host_aliases(self):
+        env_map = _build_exposed_services_env_map(
+            [
+                {"hostname": "123.example.com", "url": "https://123.example.com", "port": 443},
+                {"hostname": "1_123.example.com", "url": "https://1_123.example.com", "port": 12321},
+                {"hostname": "2_123.example.com", "url": "https://2_123.example.com", "port": 12322},
+            ]
+        )
+
+        self.assertEqual(env_map["PORTACODE_PUBLIC_HOST"], "123.example.com")
+        self.assertEqual(env_map["PORTACODE_PUBLIC_HOST_1"], "123.example.com")
+        self.assertEqual(env_map["PORTACODE_PUBLIC_HOST_2"], "1_123.example.com")
+        self.assertEqual(env_map["PORTACODE_PUBLIC_HOST_3"], "2_123.example.com")
+
+    @patch("portacode.connection.handlers.cloudflare_forwarding._push_root_file_to_container")
+    @patch("portacode.connection.handlers.cloudflare_forwarding._resolve_device_vmid", return_value=321)
+    def test_sync_exposed_services_into_container_pushes_only_canonical_json(
+        self,
+        _mock_resolve_vmid,
+        mock_push,
+    ):
+        exposed_ports = [
+            {"hostname": "123.example.com", "url": "https://123.example.com", "port": 443},
+        ]
+
+        _sync_exposed_services_into_container(
+            container_device_id="123",
+            exposed_ports=exposed_ports,
+            proxmox=object(),
+            node="pve",
+        )
+
+        mock_push.assert_called_once()
+        vmid, path, data = mock_push.call_args.args[:3]
+        self.assertEqual(vmid, 321)
+        self.assertEqual(path, EXPOSED_SERVICES_JSON_PATH)
+        self.assertEqual(
+            json.loads(data.decode("utf-8")),
+            {
+                "device_id": "123",
+                "exposed_services": exposed_ports,
+            },
+        )
+        self.assertEqual(mock_push.call_args.kwargs["mode"], 0o644)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.5.32.dev2
+Version: 1.5.33.dev0
 Summary: Connect real machines to the Portacode AI development environment
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian