portacode 1.3.32__py3-none-any.whl → 1.4.11.dev0__py3-none-any.whl

portacode/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.3.32'
-__version_tuple__ = version_tuple = (1, 3, 32)
+__version__ = version = '1.4.11.dev0'
+__version_tuple__ = version_tuple = (1, 4, 11, 'dev0')
 
 __commit_id__ = commit_id = None

portacode/cli.py

@@ -7,17 +7,25 @@ from multiprocessing import Process
 from pathlib import Path
 import signal
 import json
+import socket
 
 import click
 import pyperclip
 
 from . import __version__
 from .data import get_pid_file, is_process_running
-from .keypair import get_or_create_keypair, fingerprint_public_key
+from .keypair import (
+    get_or_create_keypair,
+    fingerprint_public_key,
+    generate_in_memory_keypair,
+    keypair_files_exist,
+)
+from .pairing import PairingError, pair_device_with_code
 from .connection.client import ConnectionManager, run_until_interrupt
 
 GATEWAY_URL = "wss://portacode.com/gateway"
 GATEWAY_ENV = "PORTACODE_GATEWAY"
+MAX_PROJECT_PATHS = 10
 
 
 @click.group()
@@ -33,7 +41,24 @@ def cli() -> None:
 @click.option("--log-categories", "log_categories", help="Comma-separated list of log categories to show (e.g., 'connection,auth,git'). Use 'list' to see available categories.")
 @click.option("--non-interactive", "non_interactive", is_flag=True, envvar="PORTACODE_NON_INTERACTIVE", hidden=True,
               help="Skip interactive prompts (used by background service)")
-def connect(gateway: str | None, detach: bool, debug: bool, log_categories: str | None, non_interactive: bool) -> None:  # noqa: D401 – Click callback
+@click.option("--pairing-code", "pairing_code_opt", envvar="PORTACODE_PAIRING_CODE", help="Provide a temporary pairing code for zero-copy onboarding")
+@click.option("--device-name", "device_name_opt", envvar="PORTACODE_DEVICE_NAME", help="Custom device name to display during pairing")
+@click.option(
+    "--project-path",
+    "project_paths_opt",
+    multiple=True,
+    help="Project folder to register during pairing (repeat for multiple paths)",
+)
+def connect(
+    gateway: str | None,
+    detach: bool,
+    debug: bool,
+    log_categories: str | None,
+    non_interactive: bool,
+    pairing_code_opt: str | None,
+    device_name_opt: str | None,
+    project_paths_opt: tuple[str, ...],
+) -> None:  # noqa: D401 – Click callback
     """Connect this machine to Portacode gateway."""
 
     # Set up debug logging if requested
@@ -74,17 +99,31 @@ def connect(gateway: str | None, detach: bool, debug: bool, log_categories: str
             other_pid = None
 
         if other_pid and is_process_running(other_pid):
-            click.echo(
-                click.style(
-                    f"Another portacode connection (PID {other_pid}) is active.", fg="yellow"
+            if other_pid == os.getpid():
+                # We just wrote our own PID (stale pidfile from previous run) – ignore safely.
+                click.echo(
+                    click.style(
+                        "Detected stale portacode pid file referencing the current process; ignoring.",
+                        fg="bright_black",
+                    )
                 )
-            )
-            if 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)
+                click.echo(
+                    click.style(
+                        f"Another portacode connection (PID {other_pid}) is active.", fg="yellow"
+                    )
+                )
+                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)
         else:
             # Stale pidfile
             pid_file.unlink(missing_ok=True)
@@ -92,12 +131,78 @@ def connect(gateway: str | None, detach: bool, debug: bool, log_categories: str
     # Determine gateway URL
     target_gateway = gateway or os.getenv(GATEWAY_ENV) or GATEWAY_URL
 
-    # 2. Load or create keypair
-    keypair = get_or_create_keypair()
+    pairing_code = pairing_code_opt.strip() if pairing_code_opt else None
+    device_name = device_name_opt.strip() if device_name_opt else None
+    normalized_project_paths: list[str] = []
+    for raw in project_paths_opt:
+        if not raw:
+            continue
+        cleaned = raw.strip()
+        if not cleaned:
+            continue
+        if len(cleaned) > 500:
+            click.echo(click.style(f"Project path too long (max 500 chars): {cleaned[:60]}…", fg="red"))
+            sys.exit(1)
+        if cleaned not in normalized_project_paths:
+            normalized_project_paths.append(cleaned)
+    if len(normalized_project_paths) > MAX_PROJECT_PATHS:
+        click.echo(
+            click.style(
+                f"Too many project paths provided ({len(normalized_project_paths)}). "
+                f"Maximum allowed is {MAX_PROJECT_PATHS}.",
+                fg="red",
+            )
+        )
+        sys.exit(1)
+
+    pairing_requested = bool(pairing_code)
+    existing_identity = keypair_files_exist()
+    should_pair = pairing_requested and not existing_identity
+
+    if normalized_project_paths and not pairing_requested:
+        click.echo(
+            click.style(
+                "⚠ Project paths were provided but no pairing code was supplied; "
+                "they will be ignored.",
+                fg="yellow",
+            )
+        )
+
+    # 2. Load or create keypair (in memory if pairing)
+    if should_pair:
+        keypair = generate_in_memory_keypair()
+    else:
+        keypair = get_or_create_keypair()
+
+    if should_pair:
+        if not device_name:
+            device_name = socket.gethostname() or "Portacode Device"
+        click.echo(click.style(f"🔐 Pairing code detected; pairing as '{device_name}'...", fg="cyan"))
+        try:
+            pair_device_with_code(
+                keypair,
+                pairing_code=pairing_code,
+                device_name=device_name,
+                project_paths=normalized_project_paths or None,
+            )
+        except PairingError as exc:
+            click.echo(click.style(f"Pairing failed: {exc}", fg="red"))
+            sys.exit(1)
+        # Persist keypair after successful approval
+        keypair = keypair.persist()
+        click.echo(click.style("✅ Pairing approved. Continuing with connection…", fg="green"))
+    elif pairing_requested and existing_identity:
+        click.echo(
+            click.style(
+                "ℹ Pairing code provided but an existing device identity was found; skipping pairing step.",
+                fg="yellow",
+            )
+        )
+
     fingerprint = fingerprint_public_key(keypair.public_key_pem)
 
     pubkey_b64 = keypair.public_key_der_b64()
-    if not non_interactive:
+    if not non_interactive and not pairing_requested:
         # Show key generation status
         if getattr(keypair, '_is_new', False):
             click.echo()
@@ -399,4 +504,4 @@ def service_status(verbose: bool) -> None:  # noqa: D401
             click.echo("\n--- system output ---")
             click.echo(mgr.status_verbose())
     except Exception as exc:
-        click.echo(click.style(f"Failed: {exc}", fg="red")) 
+        click.echo(click.style(f"Failed: {exc}", fg="red")) 

portacode/connection/client.py

@@ -8,6 +8,8 @@ from typing import Optional
 import json
 import base64
 import sys
+import secrets
+import time
 
 import websockets
 from websockets import WebSocketClientProtocol
@@ -36,6 +38,12 @@ class ConnectionManager:
         service manager restart.
     """
 
+    CLOCK_SYNC_INTERVAL = 60.0
+    CLOCK_SYNC_FAST_INTERVAL = 1.0
+    CLOCK_SYNC_INITIAL_REQUESTS = 5
+    CLOCK_SYNC_TIMEOUT = 20.0
+    CLOCK_SYNC_MAX_FAILURES = 3
+
     def __init__(self, gateway_url: str, keypair: KeyPair, reconnect_delay: float = 1.0, max_retries: int = None, debug: bool = False):
         self.gateway_url = gateway_url
         self.keypair = keypair
@@ -49,6 +57,12 @@ class ConnectionManager:
 
         self.websocket: Optional[WebSocketClientProtocol] = None
         self.mux: Optional[Multiplexer] = None
+        self._clock_sync_task: Optional[asyncio.Task[None]] = None
+        self._clock_sync_future: Optional[asyncio.Future] = None
+        self._clock_sync_request_id: Optional[str] = None
+        self._clock_sync_sent_at: Optional[float] = None
+        self._clock_sync_failures = 0
+        self._remaining_initial_syncs = self.CLOCK_SYNC_INITIAL_REQUESTS
 
     async def start(self) -> None:
         """Start the background task that maintains the connection."""
@@ -93,8 +107,12 @@ class ConnectionManager:
                     except Exception as exc:
                         logger.warning("TerminalManager unavailable: %s", LogCategory.TERMINAL, exc)
 
-                    # Start main receive loop until closed or stop requested
-                    await self._listen()
+                    self._start_clock_sync_task()
+                    try:
+                        # Start main receive loop until closed or stop requested
+                        await self._listen()
+                    finally:
+                        await self._stop_clock_sync_task()
             except (OSError, websockets.WebSocketException, asyncio.TimeoutError) as exc:
                 attempt += 1
                 logger.warning("Connection error: %s", LogCategory.CONNECTION, exc)
@@ -142,6 +160,7 @@ class ConnectionManager:
                 print("Press Cmd+C to close the connection.")
             else:
                 print("Press Ctrl+C to close the connection.")
+        # Finished authentication flow.
 
     async def _listen(self) -> None:
         assert self.websocket is not None, "WebSocket not ready"
@@ -149,11 +168,17 @@ class ConnectionManager:
             try:
                 message = await asyncio.wait_for(self.websocket.recv(), timeout=1.0)
 
-                # Add device_receive timestamp if trace present
                 try:
-                    import json
                     data = json.loads(message)
+                except Exception:
+                    data = None
+
+                if isinstance(data, dict):
                     payload = data.get("payload", {})
+                    if isinstance(payload, dict) and payload.get("event") == "clock_sync_response":
+                        receive_time_ms = int(time.time() * 1000)
+                        await self._handle_clock_sync_response(payload, receive_time_ms)
+                        continue
                     if isinstance(payload, dict) and "trace" in payload and "request_id" in payload:
                         from portacode.utils.ntp_clock import ntp_clock
                         device_receive_time = ntp_clock.now_ms()
@@ -161,11 +186,8 @@ class ConnectionManager:
                             payload["trace"]["device_receive"] = device_receive_time
                             if "client_send" in payload["trace"]:
                                 payload["trace"]["ping"] = device_receive_time - payload["trace"]["client_send"]
-                            # Re-serialize with updated trace
                             message = json.dumps(data)
                             logger.info(f"📥 Device received traced message: {payload['request_id']}")
-                except:
-                    pass  # Not a traced message, continue normally
 
                 if self.mux:
                     await self.mux.on_raw_message(message)
@@ -179,6 +201,103 @@ class ConnectionManager:
         except Exception:
             pass
 
+    def _start_clock_sync_task(self) -> None:
+        if self._clock_sync_task:
+            self._clock_sync_task.cancel()
+        self._clock_sync_task = asyncio.create_task(self._clock_sync_loop())
+        self._remaining_initial_syncs = self.CLOCK_SYNC_INITIAL_REQUESTS
+
+    async def _stop_clock_sync_task(self) -> None:
+        if self._clock_sync_task:
+            self._clock_sync_task.cancel()
+            try:
+                await self._clock_sync_task
+            except asyncio.CancelledError:
+                pass
+            self._clock_sync_task = None
+        if self._clock_sync_future and not self._clock_sync_future.done():
+            self._clock_sync_future.cancel()
+        self._clock_sync_future = None
+        self._clock_sync_request_id = None
+        self._clock_sync_sent_at = None
+
+    async def _clock_sync_loop(self) -> None:
+        try:
+            while self._remaining_initial_syncs > 0 and not self._stop_event.is_set():
+                await self._perform_clock_sync()
+                self._remaining_initial_syncs -= 1
+                if self._remaining_initial_syncs > 0:
+                    await asyncio.sleep(self.CLOCK_SYNC_FAST_INTERVAL)
+        except asyncio.CancelledError:
+            pass
+
+    async def _perform_clock_sync(self) -> None:
+        if not self.websocket or getattr(self.websocket, "closed", False):
+            return
+        request_id = f"clock_sync:{secrets.token_urlsafe(6)}"
+        payload = {
+            "event": "clock_sync_request",
+            "request_id": request_id,
+        }
+        message = json.dumps({"channel": 0, "payload": payload})
+        self._clock_sync_request_id = request_id
+        self._clock_sync_sent_at = int(time.time() * 1000)
+        loop = asyncio.get_running_loop()
+        self._clock_sync_future = loop.create_future()
+        try:
+            await self.websocket.send(message)
+        except Exception as exc:
+            logger.warning("Clock sync send failed: %s", exc)
+            await self._handle_clock_sync_timeout()
+            return
+
+        try:
+            await asyncio.wait_for(self._clock_sync_future, timeout=self.CLOCK_SYNC_TIMEOUT)
+            self._clock_sync_failures = 0
+        except asyncio.TimeoutError:
+            await self._handle_clock_sync_timeout()
+        finally:
+            self._clock_sync_future = None
+            self._clock_sync_request_id = None
+            self._clock_sync_sent_at = None
+
+    async def _handle_clock_sync_response(self, payload: dict, receive_time_ms: int) -> None:
+        if payload.get("request_id") != self._clock_sync_request_id:
+            return
+        if self._clock_sync_future and not self._clock_sync_future.done():
+            self._clock_sync_future.set_result(payload)
+        server_receive_time = payload.get("server_receive_time")
+        server_send_time = payload.get("server_send_time")
+        if server_receive_time is not None and server_send_time is not None:
+            processing_latency = max(server_send_time - server_receive_time, 0)
+            server_time = round(server_receive_time + processing_latency / 2)
+        elif server_receive_time is not None:
+            server_time = server_receive_time
+        elif server_send_time is not None:
+            server_time = server_send_time
+        else:
+            server_time = payload.get("server_time")
+        sent_at = self._clock_sync_sent_at
+        if server_time is None or sent_at is None:
+            return
+        round_trip_ms = max(receive_time_ms - sent_at, 0)
+        from portacode.utils.ntp_clock import ntp_clock
+        ntp_clock.update_from_server(server_time, round_trip_ms)
+        self._clock_sync_failures = 0
+
+    async def _handle_clock_sync_timeout(self) -> None:
+        self._clock_sync_failures += 1
+        logger.warning(
+            "Clock sync timeout (%d/%d), scheduling reconnect...",
+            self._clock_sync_failures,
+            self.CLOCK_SYNC_MAX_FAILURES,
+        )
+        if self._clock_sync_failures >= self.CLOCK_SYNC_MAX_FAILURES and self.websocket:
+            try:
+                await self.websocket.close()
+            except Exception:
+                pass
+
 
 async def run_until_interrupt(manager: ConnectionManager) -> None:
     stop_event = asyncio.Event()
@@ -206,4 +325,4 @@ async def run_until_interrupt(manager: ConnectionManager) -> None:
         # TODO: Add cleanup logic here (e.g., close sockets, remove PID files, flush logs)
         pass
     await manager.stop()
-    # TODO: Add any final cleanup logic here (e.g., remove PID files, flush logs) 
+    # TODO: Add any final cleanup logic here (e.g., remove PID files, flush logs)