pactown 0.1.4__py3-none-any.whl → 0.1.47__py3-none-any.whl

pactown/user_isolation.py

@@ -0,0 +1,458 @@
+"""
+User isolation module for pactown.
+
+Provides Linux user-based sandbox isolation for multi-tenant SaaS:
+- Create isolated Linux users per SaaS user
+- Run sandboxes under isolated user accounts
+- Easy migration of projects between hosts
+- Resource limits via cgroups (optional)
+"""
+
+import grp
+import os
+import pwd
+import re
+import shutil
+import subprocess
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from threading import Lock
+
+logger = logging.getLogger("pactown.isolation")
+
+
+def _sanitize_gecos(value: str) -> str:
+    v = str(value or "")
+    v = v.replace(":", "_")
+    v = re.sub(r"[\x00\r\n\t]", " ", v)
+    v = re.sub(r"\s+", " ", v).strip()
+    if not v:
+        v = "pactown-user"
+    return v[:200]
+
+
+@dataclass
+class IsolatedUser:
+    """Represents an isolated Linux user for sandbox execution."""
+    saas_user_id: str
+    linux_username: str
+    linux_uid: int
+    linux_gid: int
+    home_dir: Path
+    created_at: float = field(default_factory=lambda: __import__('time').time())
+    
+    def to_dict(self) -> dict:
+        return {
+            "saas_user_id": self.saas_user_id,
+            "linux_username": self.linux_username,
+            "linux_uid": self.linux_uid,
+            "linux_gid": self.linux_gid,
+            "home_dir": str(self.home_dir),
+            "created_at": self.created_at,
+        }
+
+
+class UserIsolationManager:
+    """
+    Manages isolated Linux users for sandbox execution.
+    
+    Each SaaS user gets a dedicated Linux user account:
+    - Username: pactown_<hash(saas_user_id)>
+    - Home dir: /home/pactown_users/<username>
+    - All sandboxes run under this user
+    
+    Benefits:
+    - Process isolation (different UIDs)
+    - File system isolation (home directories)
+    - Easy migration (tar user's home dir)
+    - Resource limits via cgroups
+    """
+    
+    PREFIX = "pactown_"
+    BASE_UID = 60000  # Start UIDs from 60000
+    BASE_GID = 60000
+    
+    def __init__(
+        self,
+        users_base: Path = Path("/home/pactown_users"),
+        enable_cgroups: bool = False,
+    ):
+        self.users_base = users_base
+        self.enable_cgroups = enable_cgroups
+        self._users: Dict[str, IsolatedUser] = {}
+        self._lock = Lock()
+        self._next_uid = self.BASE_UID
+        
+        # Create base directory if running as root
+        if os.geteuid() == 0:
+            self.users_base.mkdir(parents=True, exist_ok=True)
+        
+        # Load existing users
+        self._load_existing_users()
+
+    def can_isolate(self) -> tuple[bool, str]:
+        if os.geteuid() != 0:
+            return False, "not running as root"
+        if shutil.which("useradd") is None:
+            return False, "missing 'useradd' (install 'passwd'/'shadow' tools)"
+        if shutil.which("groupadd") is None:
+            return False, "missing 'groupadd' (install 'passwd'/'shadow' tools)"
+        try:
+            self.users_base.mkdir(parents=True, exist_ok=True)
+        except Exception as e:
+            return False, f"cannot create users_base={self.users_base}: {e}"
+        try:
+            if not os.access(self.users_base, os.W_OK | os.X_OK):
+                return False, f"users_base not writable: {self.users_base}"
+        except Exception as e:
+            return False, f"cannot check permissions for users_base={self.users_base}: {e}"
+        return True, ""
+    
+    def _load_existing_users(self):
+        """Load existing pactown users from system."""
+        try:
+            for entry in pwd.getpwall():
+                if entry.pw_name.startswith(self.PREFIX):
+                    # Extract saas_user_id from comment field or username
+                    saas_id = entry.pw_gecos or entry.pw_name[len(self.PREFIX):]
+                    self._users[saas_id] = IsolatedUser(
+                        saas_user_id=saas_id,
+                        linux_username=entry.pw_name,
+                        linux_uid=entry.pw_uid,
+                        linux_gid=entry.pw_gid,
+                        home_dir=Path(entry.pw_dir),
+                    )
+                    if entry.pw_uid >= self._next_uid:
+                        self._next_uid = entry.pw_uid + 1
+        except Exception as e:
+            logger.warning(f"Could not load existing users: {e}")
+    
+    def _generate_username(self, saas_user_id: str) -> str:
+        """Generate Linux username from SaaS user ID."""
+        import hashlib
+        hash_suffix = hashlib.sha256(saas_user_id.encode()).hexdigest()[:8]
+        return f"{self.PREFIX}{hash_suffix}"
+    
+    def get_or_create_user(self, saas_user_id: str) -> IsolatedUser:
+        """Get or create an isolated Linux user for a SaaS user."""
+        with self._lock:
+            if saas_user_id in self._users:
+                return self._users[saas_user_id]
+            
+            # Create new user
+            username = self._generate_username(saas_user_id)
+            uid = self._next_uid
+            gid = self._next_uid
+            home_dir = self.users_base / username
+
+            # If user already exists (deterministic username), reuse it.
+            try:
+                existing = pwd.getpwnam(username)
+                user = IsolatedUser(
+                    saas_user_id=saas_user_id,
+                    linux_username=existing.pw_name,
+                    linux_uid=existing.pw_uid,
+                    linux_gid=existing.pw_gid,
+                    home_dir=Path(existing.pw_dir),
+                )
+                self._users[saas_user_id] = user
+                if existing.pw_uid >= self._next_uid:
+                    self._next_uid = existing.pw_uid + 1
+                logger.info(
+                    "Reusing existing Linux user %s (uid=%s) for %s",
+                    user.linux_username,
+                    user.linux_uid,
+                    saas_user_id,
+                )
+                return user
+            except KeyError:
+                pass
+            
+            # Check if we can create users (requires root)
+            if os.geteuid() != 0:
+                # Non-root mode: create virtual user for tracking
+                logger.warning(f"Not running as root, creating virtual user for {saas_user_id}")
+                user = IsolatedUser(
+                    saas_user_id=saas_user_id,
+                    linux_username=username,
+                    linux_uid=os.getuid(),  # Use current user
+                    linux_gid=os.getgid(),
+                    home_dir=home_dir,
+                )
+                self._users[saas_user_id] = user
+                
+                # Create home directory anyway
+                try:
+                    home_dir.mkdir(parents=True, exist_ok=True)
+                except Exception as e:
+                    fallback_base = Path("/tmp/pactown_users")
+                    fallback_home = fallback_base / username
+                    logger.warning(
+                        "Could not create users_base home_dir=%s (%s); falling back to %s",
+                        home_dir,
+                        e,
+                        fallback_home,
+                    )
+                    fallback_home.mkdir(parents=True, exist_ok=True)
+                    user.home_dir = fallback_home
+                return user
+
+            can_isolate, reason = self.can_isolate()
+            if not can_isolate:
+                raise RuntimeError(f"User isolation unavailable: {reason}")
+            
+            try:
+                # Create group
+                try:
+                    grp.getgrnam(username)
+                except KeyError:
+                    res = subprocess.run(
+                        ["groupadd", "-g", str(gid), username],
+                        check=True,
+                        capture_output=True,
+                        text=True,
+                    )
+                    if res.stdout:
+                        logger.debug("groupadd stdout: %s", res.stdout.strip())
+                    if res.stderr:
+                        logger.debug("groupadd stderr: %s", res.stderr.strip())
+                
+                # Create user
+                safe_comment = _sanitize_gecos(saas_user_id)
+                res = subprocess.run(
+                    [
+                        "useradd",
+                        "-u",
+                        str(uid),
+                        "-g",
+                        str(gid),
+                        "-d",
+                        str(home_dir),
+                        "-m",
+                        "-s",
+                        "/bin/bash",
+                        "-c",
+                        safe_comment,
+                        username,
+                    ],
+                    check=True,
+                    capture_output=True,
+                    text=True,
+                )
+                if res.stdout:
+                    logger.debug("useradd stdout: %s", res.stdout.strip())
+                if res.stderr:
+                    logger.debug("useradd stderr: %s", res.stderr.strip())
+                
+                logger.info(f"Created Linux user {username} (uid={uid}) for {saas_user_id}")
+                
+            except subprocess.CalledProcessError as e:
+                stderr = getattr(e, "stderr", None)
+                stdout = getattr(e, "stdout", None)
+                logger.error(
+                    "Failed to create isolated user for %s: cmd=%s returncode=%s stdout=%s stderr=%s",
+                    saas_user_id,
+                    getattr(e, "cmd", None),
+                    getattr(e, "returncode", None),
+                    (stdout.strip() if isinstance(stdout, str) else stdout),
+                    (stderr.strip() if isinstance(stderr, str) else stderr),
+                )
+                raise RuntimeError(
+                    f"Failed to create isolated user (saas_user_id={saas_user_id}, username={username}): {e}"
+                )
+            
+            user = IsolatedUser(
+                saas_user_id=saas_user_id,
+                linux_username=username,
+                linux_uid=uid,
+                linux_gid=gid,
+                home_dir=home_dir,
+            )
+            
+            self._users[saas_user_id] = user
+            self._next_uid += 1
+            
+            return user
+    
+    def get_user(self, saas_user_id: str) -> Optional[IsolatedUser]:
+        """Get isolated user without creating."""
+        return self._users.get(saas_user_id)
+    
+    def get_sandbox_path(self, saas_user_id: str, service_id: str) -> Path:
+        """Get sandbox path for a specific service under user's home."""
+        user = self.get_or_create_user(saas_user_id)
+        sandbox_dir = user.home_dir / "sandboxes" / service_id
+        sandbox_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Set ownership if root
+        if os.geteuid() == 0:
+            os.chown(sandbox_dir, user.linux_uid, user.linux_gid)
+        
+        return sandbox_dir
+    
+    def run_as_user(
+        self,
+        saas_user_id: str,
+        command: str,
+        cwd: Path,
+        env: Optional[Dict[str, str]] = None,
+    ) -> subprocess.Popen:
+        """
+        Run a command as the isolated user.
+        
+        Returns subprocess.Popen for the running process.
+        """
+        user = self.get_or_create_user(saas_user_id)
+        
+        full_env = os.environ.copy()
+        full_env["HOME"] = str(user.home_dir)
+        full_env["USER"] = user.linux_username
+        full_env["LOGNAME"] = user.linux_username
+        if env:
+            full_env.update(env)
+        
+        def set_user():
+            """Pre-exec function to switch user."""
+            if os.geteuid() == 0:
+                os.setgid(user.linux_gid)
+                os.setuid(user.linux_uid)
+        
+        process = subprocess.Popen(
+            command,
+            shell=True,
+            cwd=str(cwd),
+            env=full_env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            preexec_fn=set_user if os.geteuid() == 0 else None,
+        )
+        
+        logger.info(f"Started process {process.pid} as user {user.linux_username}")
+        return process
+    
+    def list_users(self) -> List[IsolatedUser]:
+        """List all isolated users."""
+        return list(self._users.values())
+    
+    def get_user_stats(self, saas_user_id: str) -> Dict[str, Any]:
+        """Get stats for a user's sandboxes."""
+        user = self.get_user(saas_user_id)
+        if not user:
+            return {"error": "User not found"}
+        
+        sandboxes_dir = user.home_dir / "sandboxes"
+        if not sandboxes_dir.exists():
+            return {
+                "user": user.to_dict(),
+                "sandbox_count": 0,
+                "total_size_mb": 0,
+            }
+        
+        sandbox_count = len(list(sandboxes_dir.iterdir()))
+        total_size = sum(
+            f.stat().st_size 
+            for f in sandboxes_dir.rglob("*") 
+            if f.is_file()
+        )
+        
+        return {
+            "user": user.to_dict(),
+            "sandbox_count": sandbox_count,
+            "total_size_mb": total_size / (1024 * 1024),
+        }
+    
+    def export_user_data(self, saas_user_id: str, output_path: Path) -> bool:
+        """
+        Export user's data for migration.
+        
+        Creates a tar.gz archive of the user's home directory.
+        """
+        user = self.get_user(saas_user_id)
+        if not user or not user.home_dir.exists():
+            return False
+        
+        try:
+            subprocess.run(
+                ["tar", "-czf", str(output_path), "-C", str(user.home_dir.parent), user.linux_username],
+                check=True,
+                capture_output=True,
+            )
+            logger.info(f"Exported user {saas_user_id} to {output_path}")
+            return True
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Failed to export user: {e}")
+            return False
+    
+    def import_user_data(self, saas_user_id: str, archive_path: Path) -> bool:
+        """
+        Import user's data from migration archive.
+        """
+        user = self.get_or_create_user(saas_user_id)
+        
+        try:
+            # Extract to user's home
+            subprocess.run(
+                ["tar", "-xzf", str(archive_path), "-C", str(self.users_base)],
+                check=True,
+                capture_output=True,
+            )
+            
+            # Fix ownership
+            if os.geteuid() == 0:
+                subprocess.run(
+                    ["chown", "-R", f"{user.linux_uid}:{user.linux_gid}", str(user.home_dir)],
+                    check=True,
+                    capture_output=True,
+                )
+            
+            logger.info(f"Imported user {saas_user_id} from {archive_path}")
+            return True
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Failed to import user: {e}")
+            return False
+    
+    def delete_user(self, saas_user_id: str, delete_home: bool = True) -> bool:
+        """Delete an isolated user."""
+        user = self.get_user(saas_user_id)
+        if not user:
+            return False
+        
+        try:
+            if os.geteuid() == 0:
+                # Delete Linux user
+                cmd = ["userdel"]
+                if delete_home:
+                    cmd.append("-r")
+                cmd.append(user.linux_username)
+                subprocess.run(cmd, check=True, capture_output=True)
+                subprocess.run(
+                    ["groupdel", user.linux_username],
+                    capture_output=True,  # May fail if group doesn't exist
+                )
+            elif delete_home and user.home_dir.exists():
+                # Non-root: just delete home directory
+                shutil.rmtree(user.home_dir)
+            
+            del self._users[saas_user_id]
+            logger.info(f"Deleted user {saas_user_id}")
+            return True
+            
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Failed to delete user: {e}")
+            return False
+
+
+# Global isolation manager instance
+_isolation_manager: Optional[UserIsolationManager] = None
+
+
+def get_isolation_manager() -> UserIsolationManager:
+    """Get global isolation manager instance."""
+    global _isolation_manager
+    if _isolation_manager is None:
+        default_base = "/home/pactown_users" if os.geteuid() == 0 else "/tmp/pactown_users"
+        users_base = Path(os.environ.get("PACTOWN_USERS_BASE", default_base))
+        _isolation_manager = UserIsolationManager(users_base=users_base)
+    return _isolation_manager

{pactown-0.1.4.dist-info → pactown-0.1.47.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pactown
-Version: 0.1.4
+Version: 0.1.47
 Summary: Decentralized Service Ecosystem Orchestrator - Build interconnected microservices from Markdown using markpact
 Project-URL: Homepage, https://github.com/wronai/pactown
 Project-URL: Repository, https://github.com/wronai/pactown
@@ -30,6 +30,8 @@ Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.0
 Requires-Dist: uvicorn>=0.20.0
 Requires-Dist: watchfiles>=0.20.0
+Provides-Extra: all
+Requires-Dist: lolm>=0.1.6; extra == 'all'
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: bump2version>=1.0; extra == 'dev'
@@ -38,6 +40,8 @@ Requires-Dist: pytest-cov>=4.0; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: ruff>=0.1; extra == 'dev'
 Requires-Dist: twine; extra == 'dev'
+Provides-Extra: llm
+Requires-Dist: lolm>=0.1.6; extra == 'llm'
 Description-Content-Type: text/markdown
 
 ![img.png](img.png)
@@ -74,6 +78,7 @@ Pactown enables you to compose multiple independent markpact projects into a uni
 
 ## Key Features
 
+### Core Features
 - **🔗 Service Composition** – Combine multiple markpact READMEs into one ecosystem
 - **📦 Local Registry** – Store and share markpact artifacts across projects
 - **🔄 Dependency Resolution** – Automatic startup order based on service dependencies
@@ -84,14 +89,43 @@ Pactown enables you to compose multiple independent markpact projects into a uni
 - **🔍 Service Discovery** – Name-based service lookup, no hardcoded URLs
 - **⚡ Config Generator** – Auto-generate config from folder of READMEs
 
-## Documentation
+### New in v0.4.0
+- **⚡ Fast Start** – Dependency caching for millisecond startup times ([docs](docs/FAST_START.md))
+- **🛡️ Security Policy** – Rate limiting, user profiles, anomaly logging ([docs](docs/SECURITY_POLICY.md))
+- **👤 User Isolation** – Linux user-based sandbox isolation for multi-tenant SaaS ([docs](docs/USER_ISOLATION.md))
+- **📊 Detailed Logging** – Structured logs with error capture ([docs](docs/LOGGING.md))
+
+---
+
+## 📚 Documentation
+
+### Quick Navigation
+
+| Category | Documents |
+|----------|-----------|
+| **Getting Started** | [Quick Start](#quick-start) · [Installation](#installation) · [Commands](#commands) |
+| **Core Concepts** | [Specification](docs/SPECIFICATION.md) · [Configuration](docs/CONFIGURATION.md) · [Network](docs/NETWORK.md) |
+| **Deployment** | [Deployment Guide](docs/DEPLOYMENT.md) · [Quadlet/VPS](docs/QUADLET.md) · [Generator](docs/GENERATOR.md) |
+| **Security** | [Security Policy](docs/SECURITY_POLICY.md) · [Quadlet Security](docs/SECURITY.md) · [User Isolation](docs/USER_ISOLATION.md) |
+| **Performance** | [Fast Start](docs/FAST_START.md) · [Logging](docs/LOGGING.md) |
+| **Comparisons** | [vs Cloudflare Workers](docs/CLOUDFLARE_WORKERS_COMPARISON.md) |
+
+### All Documentation
 
 | Document | Description |
 |----------|-------------|
 | [Specification](docs/SPECIFICATION.md) | Architecture and design |
 | [Configuration](docs/CONFIGURATION.md) | YAML config reference |
+| [Deployment](docs/DEPLOYMENT.md) | Production deployment guide (Compose/Kubernetes/Quadlet) |
 | [Network](docs/NETWORK.md) | Dynamic ports & service discovery |
 | [Generator](docs/GENERATOR.md) | Auto-generate configs |
+| [Quadlet](docs/QUADLET.md) | Podman Quadlet deployment for VPS production |
+| [Security](docs/SECURITY.md) | Quadlet security hardening and injection test suite |
+| [Security Policy](docs/SECURITY_POLICY.md) | Rate limiting, user profiles, resource monitoring |
+| [Fast Start](docs/FAST_START.md) | Dependency caching for fast startup |
+| [User Isolation](docs/USER_ISOLATION.md) | Linux user-based sandbox isolation |
+| [Logging](docs/LOGGING.md) | Structured logging and error capture |
+| [Cloudflare Workers comparison](docs/CLOUDFLARE_WORKERS_COMPARISON.md) | When to use Pactown vs Cloudflare Workers |
 
 ### Source Code Reference
 
@@ -102,7 +136,29 @@ Pactown enables you to compose multiple independent markpact projects into a uni
 | [`resolver.py`](src/pactown/resolver.py) | Dependency resolution |
 | [`network.py`](src/pactown/network.py) | Port allocation & discovery |
 | [`generator.py`](src/pactown/generator.py) | Config file generator |
+| [`service_runner.py`](src/pactown/service_runner.py) | High-level service runner API |
+| [`security.py`](src/pactown/security.py) | Security policy & rate limiting |
+| [`fast_start.py`](src/pactown/fast_start.py) | Dependency caching & fast startup |
+| [`user_isolation.py`](src/pactown/user_isolation.py) | Linux user isolation for multi-tenant |
+| [`sandbox_manager.py`](src/pactown/sandbox_manager.py) | Sandbox lifecycle management |
 | [`registry/`](src/pactown/registry/) | Local artifact registry |
+| [`deploy/`](src/pactown/deploy/) | Deployment backends (Docker, Podman, K8s, Quadlet) |
+
+---
+
+## 🎯 Examples
+
+| Example | What it shows |
+|---------|---------------|
+| [`examples/saas-platform/`](examples/saas-platform/) | Complete SaaS with Web + API + Database + Gateway |
+| [`examples/quadlet-vps/`](examples/quadlet-vps/) | VPS setup and Quadlet workflow |
+| [`examples/email-llm-responder/`](examples/email-llm-responder/) | Email automation with LLM integration |
+| [`examples/api-gateway-webhooks/`](examples/api-gateway-webhooks/) | API gateway / webhook handler |
+| [`examples/realtime-notifications/`](examples/realtime-notifications/) | WebSocket + SSE real-time notifications |
+| [`examples/microservices/`](examples/microservices/) | Multi-language microservices |
+| [`examples/fast-start-demo/`](examples/fast-start-demo/) | **NEW:** Fast startup with dependency caching |
+| [`examples/security-policy/`](examples/security-policy/) | **NEW:** Rate limiting and user profiles |
+| [`examples/user-isolation/`](examples/user-isolation/) | **NEW:** Multi-tenant user isolation |
 
 ## Installation
 
@@ -145,31 +201,31 @@ services:
 
 Each service is a standard markpact README:
 
-```markdown
+````markdown
 # API Service
 
 REST API for the application.
 
 ---
 
-\`\`\`markpact:deps python
+```python markpact:deps
 fastapi
 uvicorn
-\`\`\`
+```
 
-\`\`\`markpact:file python path=main.py
+```python markpact:file path=main.py
 from fastapi import FastAPI
 app = FastAPI()
 
 @app.get("/health")
 def health():
     return {"status": "ok"}
-\`\`\`
+```
 
-\`\`\`markpact:run python
+```bash markpact:run
 uvicorn main:app --port ${MARKPACT_PORT:-8001}
-\`\`\`
 ```
+````
 
 ### 3. Start the ecosystem
 

pactown-0.1.47.dist-info/RECORD

@@ -0,0 +1,36 @@
+pactown/__init__.py,sha256=mmmdTjBpjrS1yjksg5JEQEbQhwQhXa-v_FkCqqu5xrI,4417
+pactown/cli.py,sha256=EoQxC5A82-kz72jO97SbPzaeDvjumpIUFyRzhbSK7jU,29731
+pactown/config.py,sha256=gDPa1Mp721W61fWxZexQTOM2-vFESoeeWGaei9SacdE,5333
+pactown/events.py,sha256=BRjUY8a9r4WKedqZK1LzC9ln3dFUnlBRVEa9kqUnSrA,36955
+pactown/fast_start.py,sha256=077Z789IJwOt2OcDl4LDQdCz9xuvZmLNKBFpstg3j-E,17141
+pactown/generator.py,sha256=Sqjn0t-D23jT-BMsMQ6x0V3jnkwf0NtU_wDkLUuUXi4,5805
+pactown/llm.py,sha256=1iwLGxX8ShxqBBRt0t2ILjH3RokADpXx2un317jraDo,14852
+pactown/markpact_blocks.py,sha256=C3ew5KKGYLsi4LFZ_FMotDKzFLfGJ70qPR8h3d3uxAw,1402
+pactown/network.py,sha256=7u6Rt8ZvCXppAE0ONKTrq0j60T1dZvgZP3LCxrMk-so,8577
+pactown/orchestrator.py,sha256=hZ4tmdcD2nTLG9HIUu_t5NhJId7-u8Cx64lGfIrEZrk,15888
+pactown/parallel.py,sha256=vz1MQqZNH6bQN803ch48Xc5zwaMrXTZrPhLu4cEAU14,8095
+pactown/platform.py,sha256=YpGA5Fb0_lIh4FKKlHs63GNbcp3cA-doJmG1FIGJypY,4442
+pactown/resolver.py,sha256=mR6gqDRuM-MXlzcuqK_GF8i9HuOj8uNS9ZoJxLSHs30,5615
+pactown/runner_api.py,sha256=V6eomMxQUyhU4I5W4p4t9EMph4aYHn3rhxend0M9v9s,17625
+pactown/sandbox_manager.py,sha256=joB6Y20cyLfgXlJEw2yElR_6UoszoRTroo1lTD6hkQc,26795
+pactown/security.py,sha256=XlrzFUd85W9xTLK-KVPgiXpYknGUFe48hyNi6ZY_EqM,24945
+pactown/service_runner.py,sha256=NR9Ydx8qZkNLDyhc46s3lFPViriHDMe2F1KC5if4O4E,45067
+pactown/user_isolation.py,sha256=MMa7-maCdr7kSpEvIpaHrD8v54Vf_d6f1Ywv8FtJV2E,16645
+pactown/deploy/__init__.py,sha256=N0cBpIShIWTOqn9XOWbqdDy6poFsnyIEPHUyTtB76TM,813
+pactown/deploy/base.py,sha256=wuO2HgOc8BQibbqQcEqYF3YuopMiUULf0qnJfxzPWec,7740
+pactown/deploy/compose.py,sha256=O7_M6Nc6Nniw70CoQ_9OIOEZpAEuTHABk85HPaL0QzE,11044
+pactown/deploy/docker.py,sha256=Y6C4wW89t-qyYZetR2PDF6KLq3KWyzMmJRexzOBrJ7k,9315
+pactown/deploy/kubernetes.py,sha256=S3hDrAEOvOJgu4qQ7TizKBD46M9DBuWocmlUdF49iKY,14567
+pactown/deploy/podman.py,sha256=Zdu5aLLecdGVKsyF0GZAxRddNnNyqfABgKvBhCaUKnk,12152
+pactown/deploy/quadlet.py,sha256=BcELmjhXmChKDIO0odnMO7prJOrPzDX-0xOb91_-IvQ,29505
+pactown/deploy/quadlet_api.py,sha256=kM6A79LFG-FhG6w5iuP-wV0fcPbWx4kGhTJJu_5_MI8,17489
+pactown/deploy/quadlet_shell.py,sha256=sYZeuz_W1RL00Ncg3sDDI5-E-h9Uo78m3rdYJ0KZcO8,18720
+pactown/registry/__init__.py,sha256=1nv3JsKStu1aPl9Jy6pEJTFg2yk6srayNIas4KjfSKs,278
+pactown/registry/client.py,sha256=kgIp9zQ_Jh_GxGAEgrsVnDNz5mYsmcf-8NvsOU9f0Ik,7750
+pactown/registry/models.py,sha256=CpUUORDAJbDbLU5KZ3F0MjluX8EAZRYOS4xINFPEf9g,5316
+pactown/registry/server.py,sha256=tnwrX6AXDDHHaxiW2bX3N_FqbbZUSFgTYZ1cB43ggp0,6161
+pactown-0.1.47.dist-info/METADATA,sha256=N5yma7rPhyOh9sKeoNza1kDv5hKsvRCWXKWVU1elm0Y,15503
+pactown-0.1.47.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pactown-0.1.47.dist-info/entry_points.txt,sha256=UH1jCyqsE6rPgxYvU1ZKOFlWZCNK0yi953y44r8W-VE,195
+pactown-0.1.47.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pactown-0.1.47.dist-info/RECORD,,

pactown-0.1.47.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+pactown = pactown.cli:main
+pactown-quadlet-api = pactown.deploy.quadlet_api:run_api
+pactown-registry = pactown.registry.server:main
+pactown-runner-api = pactown.runner_api:main

pactown-0.1.4.dist-info/RECORD

@@ -1,24 +0,0 @@
-pactown/__init__.py,sha256=w9Wv0Ssx_yWabMDy1JJh9oa4Vk7Uj_gDQvdo3cOXbeo,640
-pactown/cli.py,sha256=P7h2-iigtV5JHN6xX9vdKd0nmbr8GFNdXavKYwiUbHs,12431
-pactown/config.py,sha256=4i0A_9AtRCy3khV4jSgIos5YnVdkALWpL27NlbKpkNA,5393
-pactown/generator.py,sha256=TBC3ElDNXo-vDj6n4nDGRynVNo1rdfeMp1hYzHjfOkI,5936
-pactown/network.py,sha256=JRr6zcn2jsr2c-rIDh5mTutPau28Y-JkROS5VeHB1D4,8013
-pactown/orchestrator.py,sha256=um2EcdNBT7UYG16T2MO-JVaDPGn3uJ67UkofLIHDy8Q,16610
-pactown/parallel.py,sha256=GpnAijFFXcqvz08QgUEpJdDoeRMQ-Fq_VxrbRmyNeqo,8362
-pactown/resolver.py,sha256=CXss7EgjkMk2J_6wUP_Dx6m4BYTbFD7dMhMfXwpf1Do,5839
-pactown/sandbox_manager.py,sha256=SrAsF6E6bM2-javMhSoLwKHiOtq6VnD3tIa7Nwlktkc,11086
-pactown/deploy/__init__.py,sha256=GP-Bon4XtUsvNpvVShlJ7cxV8leOv2Pk2bhcHxMpPBs,473
-pactown/deploy/base.py,sha256=8rIyq4wl1QSXeQqWA9DTvr9d70dae2WhA4BXHtgm8fg,7535
-pactown/deploy/compose.py,sha256=eBDn_8QPUpnBQOw6S7fA-xS-bzYAEd9XKuKWDwz2kQ4,11427
-pactown/deploy/docker.py,sha256=5MQOdH78KnyrNRq4sCPNIA8cjifU8uHT7gbkQA-zosA,9633
-pactown/deploy/kubernetes.py,sha256=1z5HVhGc1K-JoNpIp2mu5OU3ufz8Fx4BH2clQjutGWI,14826
-pactown/deploy/podman.py,sha256=U8cTSTKfiHSCBbQvqhicYXO3XJpdu4f2kURo62Xp2sA,12574
-pactown/registry/__init__.py,sha256=_OPop2RWt8cjdsV6EYCIXEkuxS4PjWm72gMiwUkCE-U,278
-pactown/registry/client.py,sha256=EoD8PTUPmJeqSe1OLuFO8M_XbEyFox2L9E3oKO2SAy4,7933
-pactown/registry/models.py,sha256=wlL9Jsl60Gf27pUe8ej-oWSxRBlFOReLsr9W7joKiPI,5293
-pactown/registry/server.py,sha256=chLI1EUhlayeoaJzMnmHyjvsSU0y2JKwOLJnle0DyuQ,6303
-pactown-0.1.4.dist-info/METADATA,sha256=tXziMYrGKzF8_DXr31aZqfUOpH4g_7zqoJPe39tgDXA,11891
-pactown-0.1.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-pactown-0.1.4.dist-info/entry_points.txt,sha256=v8Wxhuh8J_-OT6Y5FjE48dzbRGXUiznz0kUxSk5gtM0,93
-pactown-0.1.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pactown-0.1.4.dist-info/RECORD,,

pactown-0.1.4.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-pactown = pactown.cli:main
-pactown-registry = pactown.registry.server:main