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

portacode/keypair.py

@@ -98,4 +98,66 @@ def fingerprint_public_key(pem: bytes) -> str:
     """Return a short fingerprint for display purposes (SHA-256)."""
     digest = hashes.Hash(hashes.SHA256())
     digest.update(pem)
-    return digest.finalize().hex()[:16] 
+    return digest.finalize().hex()[:16]
+
+
+class InMemoryKeyPair:
+    """Keypair kept purely in memory until explicitly persisted."""
+
+    def __init__(self, private_pem: bytes, public_pem: bytes, key_dir: Path):
+        self._private_pem = private_pem
+        self._public_pem = public_pem
+        self._key_dir = key_dir
+        self._is_new = True
+
+    @property
+    def private_key_pem(self) -> bytes:
+        return self._private_pem
+
+    @property
+    def public_key_pem(self) -> bytes:
+        return self._public_pem
+
+    def sign_challenge(self, challenge: str) -> bytes:
+        private_key = serialization.load_pem_private_key(self._private_pem, password=None)
+        return private_key.sign(
+            challenge.encode(),
+            padding.PKCS1v15(),
+            hashes.SHA256(),
+        )
+
+    def public_key_der_b64(self) -> str:
+        pubkey = serialization.load_pem_public_key(self._public_pem)
+        der = pubkey.public_bytes(
+            encoding=serialization.Encoding.DER,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo,
+        )
+        return base64.b64encode(der).decode()
+
+    def persist(self) -> KeyPair:
+        """Write the keypair to disk and return a regular KeyPair."""
+        key_dir = self._key_dir
+        key_dir.mkdir(parents=True, exist_ok=True)
+        priv_path = key_dir / PRIVATE_KEY_FILE
+        pub_path = key_dir / PUBLIC_KEY_FILE
+        priv_path.write_bytes(self._private_pem)
+        pub_path.write_bytes(self._public_pem)
+        keypair = KeyPair(priv_path, pub_path)
+        keypair._is_new = True  # type: ignore[attr-defined]
+        keypair._key_dir = key_dir  # type: ignore[attr-defined]
+        return keypair
+
+
+def generate_in_memory_keypair() -> InMemoryKeyPair:
+    """Generate a new keypair but keep it in memory until pairing succeeds."""
+    private_pem, public_pem = _generate_keypair()
+    key_dir = get_key_dir()
+    return InMemoryKeyPair(private_pem, public_pem, key_dir)
+
+
+def keypair_files_exist() -> bool:
+    """Return True if the persisted keypair already exists on disk."""
+    key_dir = get_key_dir()
+    priv_path = key_dir / PRIVATE_KEY_FILE
+    pub_path = key_dir / PUBLIC_KEY_FILE
+    return priv_path.exists() and pub_path.exists()

portacode/link_capture/__init__.py

@@ -0,0 +1,38 @@
+"""Helpers for the link capture wrapper scripts."""
+
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+try:
+    # Use the stdlib helpers when they are available (Python ≥3.9).
+    from importlib.resources import as_file, files
+except ImportError:  # pragma: no cover
+    # Fall back to the backport for older Python 3.x runtimes (>=3.6).
+    from importlib_resources import as_file, files
+
+_LINK_CAPTURE_TEMP_DIR: Optional[Path] = None
+
+
+def prepare_link_capture_bin() -> Optional[Path]:
+    """Extract the packaged link capture wrappers into a temporary dir and return it."""
+    global _LINK_CAPTURE_TEMP_DIR
+    if _LINK_CAPTURE_TEMP_DIR:
+        return _LINK_CAPTURE_TEMP_DIR
+
+    bin_source = files(__package__) / "bin"
+    if not bin_source.is_dir():
+        return None
+
+    temp_dir = Path(tempfile.mkdtemp(prefix="portacode-link-capture-"))
+    for entry in bin_source.iterdir():
+        if not entry.is_file():
+            continue
+        with as_file(entry) as file_path:
+            dest = temp_dir / entry.name
+            shutil.copyfile(file_path, dest)
+            dest.chmod(dest.stat().st_mode | 0o111)
+
+    _LINK_CAPTURE_TEMP_DIR = temp_dir
+    return _LINK_CAPTURE_TEMP_DIR

portacode/link_capture/bin/elinks

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" elinks "$@"

portacode/link_capture/bin/gio-open

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" gio-open "$@"

portacode/link_capture/bin/gnome-open

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" gnome-open "$@"

portacode/link_capture/bin/gvfs-open

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" gvfs-open "$@"

portacode/link_capture/bin/kde-open

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" kde-open "$@"

portacode/link_capture/bin/kfmclient

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" kfmclient "$@"

portacode/link_capture/bin/link_capture_exec.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+COMMAND_NAME="$1"
+shift
+
+if [ -z "$COMMAND_NAME" ]; then
+  echo "link_capture: missing command name" >&2
+  exit 1
+fi
+
+exec "$SCRIPT_DIR/link_capture_wrapper.py" "$COMMAND_NAME" "$@"

portacode/link_capture/bin/link_capture_wrapper.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""Simple link capture wrapper that never executes a native browser."""
+
+import json
+import os
+import sys
+import time
+import uuid
+from pathlib import Path
+from urllib.parse import urlparse
+
+LINK_CHANNEL_ENV = "PORTACODE_LINK_CHANNEL"
+TERMINAL_ID_ENV = "PORTACODE_TERMINAL_ID"
+
+
+def _find_link_argument(args):
+    for arg in args:
+        if not isinstance(arg, str):
+            continue
+        parsed = urlparse(arg)
+        if parsed.scheme and parsed.netloc:
+            return arg
+        if arg.startswith("file://"):
+            return arg
+    return None
+
+
+def _write_capture_event(cmd_name, args, link):
+    channel = os.environ.get(LINK_CHANNEL_ENV)
+    terminal_id = os.environ.get(TERMINAL_ID_ENV)
+    if not channel or not link:
+        return
+    payload = {
+        "terminal_id": terminal_id,
+        "command": cmd_name,
+        "args": args,
+        "url": link,
+        "timestamp": time.time(),
+    }
+    directory = Path(channel)
+    try:
+        directory.mkdir(parents=True, exist_ok=True)
+    except Exception:
+        return
+    temp_file = directory / f".{uuid.uuid4().hex}.tmp"
+    term_label = terminal_id or "unknown"
+    base_name = f"{int(time.time() * 1000)}-{term_label}"
+    final_file = directory / f"{base_name}.json"
+    suffix = 0
+    while final_file.exists():
+        suffix += 1
+        final_file = directory / f"{base_name}-{suffix}.json"
+    try:
+        temp_file.write_text(json.dumps(payload), encoding="utf-8")
+        temp_file.replace(final_file)
+    except Exception:
+        if temp_file.exists():
+            temp_file.unlink(missing_ok=True)
+
+
+def main() -> None:
+    if len(sys.argv) < 2:
+        sys.stderr.write("link_capture: missing target command name\n")
+        sys.exit(1)
+    cmd_name = sys.argv[1]
+    cmd_args = sys.argv[2:]
+    link = _find_link_argument(cmd_args)
+    if link:
+        _write_capture_event(cmd_name, cmd_args, link)
+    # Never run a real browser; capture and exit successfully.
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

portacode/link_capture/bin/links

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" links "$@"

portacode/link_capture/bin/links2

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" links2 "$@"

portacode/link_capture/bin/lynx

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" lynx "$@"

portacode/link_capture/bin/mate-open

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" mate-open "$@"

portacode/link_capture/bin/netsurf

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" netsurf "$@"

portacode/link_capture/bin/sensible-browser

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" sensible-browser "$@"

portacode/link_capture/bin/w3m

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" w3m "$@"

portacode/link_capture/bin/x-www-browser

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" x-www-browser "$@"

portacode/link_capture/bin/xdg-open

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" xdg-open "$@"

portacode/logging_categories.py

@@ -0,0 +1,140 @@
+"""
+Categorized logging system for Portacode CLI.
+
+This module provides a logging system that allows filtering by categories
+to help developers focus on specific aspects of the application during debugging.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Set, Optional
+from enum import Enum
+
+
+class LogCategory(Enum):
+    """Available log categories for filtering."""
+    CONNECTION = "connection"
+    AUTHENTICATION = "auth"
+    WEBSOCKET = "websocket"
+    TERMINAL = "terminal"
+    PROJECT_STATE = "project_state"
+    FILE_SYSTEM = "filesystem"
+    GIT = "git"
+    HANDLERS = "handlers"
+    MULTIPLEXER = "mux"
+    SYSTEM = "system"
+    DEBUG = "debug"
+
+
+class CategorizedLogger:
+    """
+    A logger that supports category-based filtering.
+    
+    This wraps the standard Python logger but adds category support
+    for fine-grained filtering during debugging.
+    """
+    
+    def __init__(self, name: str, enabled_categories: Optional[Set[str]] = None):
+        self.logger = logging.getLogger(name)
+        self.enabled_categories = enabled_categories or set()
+        self._all_enabled = len(self.enabled_categories) == 0  # If no categories specified, show all
+    
+    def _should_log(self, category: LogCategory) -> bool:
+        """Check if a log with this category should be output."""
+        if self._all_enabled:
+            return True
+        return category.value in self.enabled_categories
+    
+    def _format_message(self, msg: str, category: LogCategory) -> str:
+        """Format message with category prefix."""
+        return f"[{category.value.upper()}] {msg}"
+    
+    def _parse_args(self, *args) -> tuple[LogCategory, tuple]:
+        """Parse arguments to extract category and remaining args."""
+        if args and isinstance(args[0], LogCategory):
+            return args[0], args[1:]
+        else:
+            return LogCategory.DEBUG, args
+    
+    def debug(self, msg: str, *args, **kwargs):
+        """Log debug message with optional category."""
+        category, remaining_args = self._parse_args(*args)
+        if self._should_log(category):
+            formatted_msg = self._format_message(msg, category)
+            self.logger.debug(formatted_msg, *remaining_args, **kwargs)
+    
+    def info(self, msg: str, *args, **kwargs):
+        """Log info message with optional category."""
+        category, remaining_args = self._parse_args(*args)
+        if self._should_log(category):
+            formatted_msg = self._format_message(msg, category)
+            self.logger.info(formatted_msg, *remaining_args, **kwargs)
+    
+    def warning(self, msg: str, *args, **kwargs):
+        """Log warning message with optional category."""
+        category, remaining_args = self._parse_args(*args)
+        if self._should_log(category):
+            formatted_msg = self._format_message(msg, category)
+            self.logger.warning(formatted_msg, *remaining_args, **kwargs)
+    
+    def error(self, msg: str, *args, **kwargs):
+        """Log error message with optional category."""
+        category, remaining_args = self._parse_args(*args)
+        if self._should_log(category):
+            formatted_msg = self._format_message(msg, category)
+            self.logger.error(formatted_msg, *remaining_args, **kwargs)
+    
+    def exception(self, msg: str, *args, **kwargs):
+        """Log exception message with optional category."""
+        category, remaining_args = self._parse_args(*args)
+        if self._should_log(category):
+            formatted_msg = self._format_message(msg, category)
+            self.logger.exception(formatted_msg, *remaining_args, **kwargs)
+
+
+# Global registry of enabled categories
+_enabled_categories: Set[str] = set()
+
+
+def configure_logging_categories(categories: Set[str]) -> None:
+    """Configure which log categories should be enabled globally."""
+    global _enabled_categories
+    _enabled_categories = categories
+
+
+def get_categorized_logger(name: str) -> CategorizedLogger:
+    """Get a categorized logger instance with current category settings."""
+    return CategorizedLogger(name, _enabled_categories)
+
+
+def list_available_categories() -> list[str]:
+    """Return a list of all available log categories."""
+    return [category.value for category in LogCategory]
+
+
+def parse_category_string(category_str: str) -> Set[str]:
+    """
+    Parse a comma-separated string of categories into a set.
+    
+    Args:
+        category_str: Comma-separated category names (e.g., "connection,auth,git")
+    
+    Returns:
+        Set of valid category names
+        
+    Raises:
+        ValueError: If any category is invalid
+    """
+    if not category_str.strip():
+        return set()
+    
+    categories = {cat.strip().lower() for cat in category_str.split(',')}
+    valid_categories = {cat.value for cat in LogCategory}
+    
+    invalid = categories - valid_categories
+    if invalid:
+        raise ValueError(f"Invalid categories: {', '.join(invalid)}. "
+                        f"Valid categories: {', '.join(sorted(valid_categories))}")
+    
+    return categories

portacode/pairing.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import socket
+from dataclasses import dataclass
+from typing import Optional
+
+import websockets
+
+PAIRING_URL_ENV = "PORTACODE_PAIRING_URL"
+DEFAULT_PAIRING_URL = "wss://portacode.com/ws/pairing/device/"
+
+
+class PairingError(Exception):
+    """Raised when pairing fails or is rejected."""
+
+
+@dataclass
+class PairingResult:
+    status: str
+    payload: dict
+
+
+async def _pair_device(
+    url: str,
+    public_key_b64: str,
+    pairing_code: str,
+    device_name: str,
+    project_paths: list[str] | None = None,
+    timeout: float = 300.0,
+) -> PairingResult:
+    async with websockets.connect(url) as ws:
+        # Initial ready/event
+        try:
+            ready = await asyncio.wait_for(ws.recv(), timeout=10)
+        except asyncio.TimeoutError as exc:
+            raise PairingError("Gateway did not acknowledge pairing request") from exc
+
+        try:
+            data = json.loads(ready)
+            if data.get("event") != "pairing_ready":
+                raise PairingError(f"Unexpected response from pairing gateway: {ready}")
+        except json.JSONDecodeError:
+            raise PairingError(f"Unexpected response from pairing gateway: {ready}") from None
+
+        payload = {
+            "code": pairing_code,
+            "device_name": device_name,
+            "public_key": public_key_b64,
+        }
+        if project_paths:
+            payload["project_paths"] = project_paths
+        await ws.send(json.dumps(payload))
+
+        while True:
+            try:
+                message = await asyncio.wait_for(ws.recv(), timeout=timeout)
+            except asyncio.TimeoutError as exc:
+                raise PairingError("Pairing timed out waiting for approval") from exc
+
+            try:
+                data = json.loads(message)
+            except json.JSONDecodeError:
+                continue
+
+            if data.get("event") != "pairing_status":
+                continue
+
+            status = data.get("status")
+            if status == "pending":
+                continue
+            if status == "approved":
+                return PairingResult(status="approved", payload=data)
+            reason = data.get("reason") or status or "unknown_error"
+            raise PairingError(reason)
+
+
+def pair_device_with_code(
+    keypair,
+    pairing_code: str,
+    device_name: Optional[str] = None,
+    project_paths: list[str] | None = None,
+    *,
+    timeout: float = 300.0,
+) -> PairingResult:
+    """Run the pairing workflow synchronously."""
+    pairing_url = os.getenv(PAIRING_URL_ENV, DEFAULT_PAIRING_URL)
+    normalized_url = pairing_url if pairing_url.startswith("ws") else f"wss://{pairing_url.lstrip('/')}"
+    friendly_name = device_name or socket.gethostname() or "Portacode Device"
+
+    public_key_b64 = keypair.public_key_der_b64()
+    return asyncio.run(
+        _pair_device(
+            normalized_url,
+            public_key_b64=public_key_b64,
+            pairing_code=pairing_code,
+            device_name=friendly_name,
+            project_paths=project_paths,
+            timeout=timeout,
+        )
+    )

portacode/service.py

@@ -92,6 +92,10 @@ class _SystemdUserService:
 
     def install(self) -> None:
         self.service_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Capture current SHELL for the service to prevent using /bin/sh in containers/virtualized environments
+        current_shell = os.getenv("SHELL", "/bin/bash")
+        
         if self.system_mode:
             sudo_needed = os.geteuid() != 0
             prefix = ["sudo"] if sudo_needed else []
@@ -104,6 +108,7 @@ class _SystemdUserService:
                 Type=simple
                 User={self.user}
                 WorkingDirectory={self.home}
+                Environment=SHELL={current_shell}
                 ExecStart={self.python} -m portacode connect --non-interactive
                 Restart=on-failure
                 RestartSec=5
@@ -119,6 +124,7 @@ class _SystemdUserService:
 
                 [Service]
                 Type=simple
+                Environment=SHELL={current_shell}
                 ExecStart={self.python} -m portacode.cli connect --non-interactive
                 Restart=on-failure
                 RestartSec=5

portacode/static/js/test-ntp-clock.html

@@ -0,0 +1,63 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>NTP Clock Test</title>
+    <style>
+        body {
+            font-family: monospace;
+            padding: 20px;
+            background: #1e1e1e;
+            color: #d4d4d4;
+        }
+        h1 {
+            color: #4ec9b0;
+        }
+        #status {
+            background: #252526;
+            padding: 15px;
+            border-radius: 5px;
+            border: 1px solid #3e3e42;
+        }
+        .synced {
+            color: #4ec9b0;
+        }
+        .not-synced {
+            color: #f48771;
+        }
+        .label {
+            color: #9cdcfe;
+            font-weight: bold;
+        }
+    </style>
+</head>
+<body>
+    <h1>NTP Clock Test - time.cloudflare.com</h1>
+    <div id="status"></div>
+    <script type="module">
+        import ntpClock from './utils/ntp-clock.js';
+
+        function updateDisplay() {
+            const status = ntpClock.getStatus();
+            const syncClass = status.isSynced ? 'synced' : 'not-synced';
+
+            document.getElementById('status').innerHTML = `
+                <p><span class="label">Sync Status:</span> <span class="${syncClass}">${status.isSynced ? '✅ SYNCED' : '❌ NOT SYNCED'}</span></p>
+                <p><span class="label">NTP Server:</span> ${status.server}</p>
+                <p><span class="label">NTP Time:</span> ${ntpClock.nowISO() || 'null (not synced)'}</p>
+                <p><span class="label">Local Time:</span> ${new Date().toISOString()}</p>
+                <p><span class="label">Offset:</span> ${status.offset !== null ? status.offset.toFixed(2) + 'ms' : 'null'}</p>
+                <p><span class="label">Last Sync:</span> ${status.lastSync || 'Never'}</p>
+                <p><span class="label">Time Since Sync:</span> ${status.timeSinceSync ? (status.timeSinceSync / 1000).toFixed(0) + 's' : 'N/A'}</p>
+            `;
+        }
+
+        // Update display every 100ms
+        setInterval(updateDisplay, 100);
+
+        // Log status to console every 5 seconds
+        setInterval(() => {
+            console.log('NTP Clock Status:', ntpClock.getStatus());
+        }, 5000);
+    </script>
+</body>
+</html>