portacode 0.3.4.dev0__py3-none-any.whl → 1.4.11.dev0__py3-none-any.whl

portacode/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.4.dev'
-__version_tuple__ = version_tuple = (0, 3, 4, 'dev0')
+__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://device.portacode.com/gateway"
+GATEWAY_URL = "wss://portacode.com/gateway"
 GATEWAY_ENV = "PORTACODE_GATEWAY"
+MAX_PROJECT_PATHS = 10
 
 
 @click.group()
@@ -29,11 +37,59 @@ def cli() -> None:
 @cli.command()
 @click.option("--gateway", "gateway", "-g", help="Gateway websocket URL (overrides env/ default)")
 @click.option("--detach", "detach", "-d", is_flag=True, help="Run connection in background")
+@click.option("--debug", "debug", is_flag=True, help="Enable debug logging")
+@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, 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
+    if debug:
+        import logging
+        from .logging_categories import configure_logging_categories, parse_category_string, list_available_categories
+        
+        # Handle log categories
+        if log_categories == "list":
+            click.echo(click.style("Available log categories:", fg="cyan"))
+            for cat in list_available_categories():
+                click.echo(f"  • {cat}")
+            return
+        
+        enabled_categories = set()
+        if log_categories:
+            try:
+                enabled_categories = parse_category_string(log_categories)
+                configure_logging_categories(enabled_categories)
+                click.echo(click.style(f"🔍 Debug logging enabled for categories: {', '.join(sorted(enabled_categories))}", fg="yellow"))
+            except ValueError as e:
+                click.echo(click.style(f"Error: {e}", fg="red"))
+                return
+        else:
+            click.echo(click.style("🔍 Debug logging enabled (all categories)", fg="yellow"))
+        
+        logging.basicConfig(
+            level=logging.DEBUG,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+
     # 1. Ensure only a single connection per user
     pid_file = get_pid_file()
     if pid_file.exists():
@@ -43,17 +99,31 @@ def connect(gateway: str | None, detach: bool, non_interactive: bool) -> None:
             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)
@@ -61,12 +131,78 @@ def connect(gateway: str | None, detach: bool, non_interactive: bool) -> None:
     # 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()
@@ -84,7 +220,7 @@ def connect(gateway: str | None, detach: bool, non_interactive: bool) -> None:
         click.echo(click.style("🚀 Welcome to Portacode!", fg="bright_blue", bold=True))
         click.echo()
         click.echo(click.style("📱 Next steps:", fg="bright_cyan", bold=True))
-        click.echo(click.style("  1. Visit ", fg="white") + click.style("https://remote.portacode.com", fg="bright_blue", underline=True))
+        click.echo(click.style("  1. Visit ", fg="white") + click.style("https://portacode.com", fg="bright_blue", underline=True))
         click.echo(click.style("  2. Create your free account or sign in", fg="white"))
         click.echo(click.style("  3. Add this device using the key below", fg="white"))
         click.echo()
@@ -172,7 +308,7 @@ def connect(gateway: str | None, detach: bool, non_interactive: bool) -> None:
         pid_file.write_text(str(os.getpid()))
 
     async def _main() -> None:
-        mgr = ConnectionManager(target_gateway, keypair)
+        mgr = ConnectionManager(target_gateway, keypair, debug=debug)
         await run_until_interrupt(mgr)
 
     try:
@@ -187,7 +323,7 @@ def _run_connection_forever(url: str, keypair, pid_file: Path):
         pid_file.write_text(str(os.getpid()))
 
         async def _main() -> None:
-            mgr = ConnectionManager(url, keypair)
+            mgr = ConnectionManager(url, keypair, debug=debug)
             await run_until_interrupt(mgr)
 
         asyncio.run(_main())
@@ -239,7 +375,7 @@ def send_control(message: str, gateway: str | None) -> None:  # noqa: D401 – C
 
     async def _run() -> None:
         keypair = get_or_create_keypair()
-        mgr = ConnectionManager(target_gateway, keypair)
+        mgr = ConnectionManager(target_gateway, keypair, debug=debug)
         await mgr.start()
 
         # Wait until mux is available & authenticated (rudimentary – 2s timeout)
@@ -368,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,14 +8,17 @@ from typing import Optional
 import json
 import base64
 import sys
+import secrets
+import time
 
 import websockets
 from websockets import WebSocketClientProtocol
 
 from ..keypair import KeyPair
 from .multiplex import Multiplexer
+from ..logging_categories import get_categorized_logger, LogCategory
 
-logger = logging.getLogger(__name__)
+logger = get_categorized_logger(__name__)
 
 
 class ConnectionManager:
@@ -24,7 +27,7 @@ class ConnectionManager:
     Parameters
     ----------
     gateway_url: str
-        WebSocket URL, e.g. ``wss://device.portacode.com/gateway``
+        WebSocket URL, e.g. ``wss://portacode.com/gateway``
     keypair: KeyPair
         User's public/private keypair used for authentication.
     reconnect_delay: float
@@ -35,10 +38,17 @@ class ConnectionManager:
         service manager restart.
     """
 
-    def __init__(self, gateway_url: str, keypair: KeyPair, reconnect_delay: float = 1.0, max_retries: int = None):
+    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
         self.reconnect_delay = reconnect_delay
+        self.debug = debug
         # max_retries is now deprecated but kept for backwards compatibility
         self.max_retries = max_retries
 
@@ -47,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."""
@@ -66,9 +82,9 @@ class ConnectionManager:
             try:
                 if attempt:
                     delay = min(self.reconnect_delay * 2 ** (attempt - 1), 30)
-                    logger.warning("Reconnecting in %.1f s (attempt %d)…", delay, attempt)
+                    logger.warning("Reconnecting in %.1f s (attempt %d)…", LogCategory.CONNECTION, delay, attempt)
                     await asyncio.sleep(delay)
-                logger.info("Connecting to gateway at %s", self.gateway_url)
+                logger.info("Connecting to gateway at %s", LogCategory.CONNECTION, self.gateway_url)
                 async with websockets.connect(self.gateway_url) as ws:
                     # Reset attempt counter after successful connection
                     attempt = 0
@@ -87,21 +103,25 @@ class ConnectionManager:
                         if getattr(self, "_terminal_manager", None):
                             self._terminal_manager.attach_mux(self.mux)
                         else:
-                            self._terminal_manager = TerminalManager(self.mux)  # noqa: pylint=attribute-defined-outside-init
+                            self._terminal_manager = TerminalManager(self.mux, debug=self.debug)  # noqa: pylint=attribute-defined-outside-init
                     except Exception as exc:
-                        logger.warning("TerminalManager unavailable: %s", 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", exc)
+                logger.warning("Connection error: %s", LogCategory.CONNECTION, exc)
                 # Remove the max_retries limit - keep trying indefinitely
                 # The service manager (systemd) will handle any necessary restarts
             except Exception as exc:
                 # For truly fatal errors (like authentication failures), 
                 # log and exit cleanly so systemd can restart the service
-                logger.exception("Fatal error in connection manager: %s", exc)
+                logger.exception("Fatal error in connection manager: %s", LogCategory.CONNECTION, exc)
                 # Exit cleanly to allow systemd restart
                 sys.exit(1)
 
@@ -140,12 +160,35 @@ 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"
         while not self._stop_event.is_set():
             try:
                 message = await asyncio.wait_for(self.websocket.recv(), timeout=1.0)
+
+                try:
+                    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()
+                        if device_receive_time is not None:
+                            payload["trace"]["device_receive"] = device_receive_time
+                            if "client_send" in payload["trace"]:
+                                payload["trace"]["ping"] = device_receive_time - payload["trace"]["client_send"]
+                            message = json.dumps(data)
+                            logger.info(f"📥 Device received traced message: {payload['request_id']}")
+
                 if self.mux:
                     await self.mux.on_raw_message(message)
             except asyncio.TimeoutError:
@@ -158,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()
@@ -185,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)