redeploy 0.2.33__tar.gz → 0.2.35__tar.gz

{redeploy-0.2.33 → redeploy-0.2.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redeploy
-Version: 0.2.33
+Version: 0.2.35
 Summary: Infrastructure migration toolkit: detect → plan → apply
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -27,17 +27,17 @@ Requires-Dist: pfix>=0.1.60; extra == "dev"
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.33-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$7.50-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-17.6h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.35-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$7.50-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-18.0h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $7.5000 (53 commits)
-- 👤 **Human dev:** ~$1758 (17.6h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $7.5000 (56 commits)
+- 👤 **Human dev:** ~$1796 (18.0h @ $100/h, 30min dedup)
 
 Generated on 2026-04-21 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 
-![PyPI](https://img.shields.io/badge/pypi-redeploy-blue) ![Version](https://img.shields.io/badge/version-0.2.33-blue) ![Python](https://img.shields.io/badge/python-3.10+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-redeploy-blue) ![Version](https://img.shields.io/badge/version-0.2.35-blue) ![Python](https://img.shields.io/badge/python-3.10+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 
 Infrastructure migration and device deploy toolkit — VPS, Raspberry Pi kiosk, Podman Quadlet, k3s.
 

{redeploy-0.2.33 → redeploy-0.2.35}/README.md

@@ -3,17 +3,17 @@
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.33-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$7.50-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-17.6h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.35-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$7.50-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-18.0h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $7.5000 (53 commits)
-- 👤 **Human dev:** ~$1758 (17.6h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $7.5000 (56 commits)
+- 👤 **Human dev:** ~$1796 (18.0h @ $100/h, 30min dedup)
 
 Generated on 2026-04-21 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 
-![PyPI](https://img.shields.io/badge/pypi-redeploy-blue) ![Version](https://img.shields.io/badge/version-0.2.33-blue) ![Python](https://img.shields.io/badge/python-3.10+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-redeploy-blue) ![Version](https://img.shields.io/badge/version-0.2.35-blue) ![Python](https://img.shields.io/badge/python-3.10+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 
 Infrastructure migration and device deploy toolkit — VPS, Raspberry Pi kiosk, Podman Quadlet, k3s.
 

{redeploy-0.2.33 → redeploy-0.2.35}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "redeploy"
-version = "0.2.33"
+version = "0.2.35"
 description = "Infrastructure migration toolkit: detect → plan → apply"
 readme = "README.md"
 requires-python = ">=3.11"

{redeploy-0.2.33 → redeploy-0.2.35}/redeploy/__init__.py

@@ -7,7 +7,7 @@ Public API (stable from 0.2.0, semver guaranteed)::
 
 Everything not listed in ``__all__`` is internal and may change without notice.
 """
-__version__ = "0.2.33"
+__version__ = "0.2.35"
 
 # ── Core models ───────────────────────────────────────────────────────────────
 from .models import (  # noqa: F401

{redeploy-0.2.33 → redeploy-0.2.35}/redeploy/apply/handlers.py

@@ -36,6 +36,10 @@ def run_scp(step: MigrationStep, probe: RemoteProbe, plan: MigrationPlan) -> Non
     """Copy file via SCP."""
     if not step.src or not step.dst:
         raise StepError(step, "scp requires src and dst")
+    if probe.is_local and Path(step.src).resolve() == Path(step.dst).resolve():
+        step.status = StepStatus.DONE
+        step.result = "skipped (same file)"
+        return
     if probe.is_local:
         cmd = ["cp", step.src, step.dst]
     else:

redeploy-0.2.35/redeploy/blueprint/__init__.py

@@ -0,0 +1,11 @@
+"""Blueprint subsystem — extract, generate and apply DeviceBlueprints.
+
+Public API::
+
+    from redeploy.blueprint import extract_blueprint, generate_twin, generate_migration
+"""
+from .extractor import extract_blueprint
+from .generators.docker_compose import generate_twin
+from .generators.migration import generate_migration
+
+__all__ = ["extract_blueprint", "generate_twin", "generate_migration"]

redeploy-0.2.35/redeploy/blueprint/extractor.py

@@ -0,0 +1,328 @@
+"""Blueprint extractor — derive a DeviceBlueprint from multiple sources.
+
+Sources (in order of priority):
+1. Running InfraState (podman ps / docker inspect on live device)
+2. DeviceMap hardware snapshot
+3. docker-compose YAML files
+4. markpact / migration YAML definitions
+
+The extractor reconciles all available information into a single
+DeviceBlueprint that is self-contained and portable.
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+from ..models import (
+    BlueprintSource,
+    DeviceBlueprint,
+    DeviceMap,
+    HardwareRequirements,
+    InfraState,
+    ServicePort,
+    ServiceSpec,
+    VolumeMount,
+)
+
+
+def extract_blueprint(
+    *,
+    name: str,
+    device_map: Optional[DeviceMap] = None,
+    infra: Optional[InfraState] = None,
+    compose_files: Optional[list[Path]] = None,
+    migration_file: Optional[Path] = None,
+    markpact_files: Optional[list[Path]] = None,
+    version: str = "0.0.0",
+    description: str = "",
+    tags: Optional[list[str]] = None,
+    detect_live: bool = False,
+    host: Optional[str] = None,
+) -> DeviceBlueprint:
+    """Build a DeviceBlueprint by reconciling all available sources.
+
+    Parameters
+    ----------
+    name:
+        Human-readable blueprint name, e.g. ``"c2004-kiosk"``.
+    device_map:
+        Previously saved DeviceMap (hardware + infra snapshot).
+    infra:
+        InfraState if already probed (skips live detection).
+    compose_files:
+        Local docker-compose YAML files to parse service specs from.
+    migration_file:
+        Local migration.yaml to extract app version and strategy from.
+    markpact_files:
+        Local markdown files with markpact fenced blocks.
+    detect_live:
+        If True and *host* is given, probe the host via SSH for a fresh
+        InfraState even if *device_map* already has one.
+    host:
+        SSH target used when ``detect_live=True``.
+    """
+    if detect_live and host and not infra:
+        from ..detect import Detector
+        infra = infra or Detector(host).run()
+
+    # Prefer freshly probed infra, fall back to device_map.infra
+    _infra: Optional[InfraState] = infra or (device_map.infra if device_map else None)
+    _hw = device_map.hardware if device_map else None
+
+    services: list[ServiceSpec] = []
+    seen: set[str] = set()
+
+    # ── 1. Live InfraState (most accurate) ────────────────────────────────────
+    if _infra:
+        for svcs in _infra.services.values():
+            for svc in svcs:
+                if svc.name in seen:
+                    continue
+                seen.add(svc.name)
+                services.append(ServiceSpec(
+                    name=svc.name,
+                    image=getattr(svc, "image", ""),
+                    platform="",                    # unknown at this point
+                    source_ref="infra:live",
+                ))
+
+    # ── 2. docker-compose files ────────────────────────────────────────────────
+    for cf in (compose_files or []):
+        _merge_compose(cf, services, seen)
+
+    # ── 3. migration.yaml ─────────────────────────────────────────────────────
+    app_version = version
+    deploy_strategy = "podman_quadlet"
+    if migration_file and migration_file.exists():
+        _meta = _parse_migration_meta(migration_file)
+        app_version = _meta.get("version", version)
+        deploy_strategy = _meta.get("strategy", deploy_strategy)
+
+    # ── 4. Hardware requirements ───────────────────────────────────────────────
+    hw_req = _build_hw_requirements(_hw)
+
+    # ── 5. App URL ─────────────────────────────────────────────────────────────
+    app_url = None
+    if _infra and _infra.host:
+        h = _infra.host.split("@")[-1]
+        # Look for a port-80 / port-8100 style proxy
+        for port in (80, 8100, 8080, 443):
+            if port in (_infra.ports or {}):
+                app_url = f"http://{h}:{port}" if port not in (80, 443) else f"http://{h}"
+                break
+
+    source = BlueprintSource(
+        device_id=device_map.id if device_map else host,
+        device_name=device_map.name if device_map else "",
+        migration_file=str(migration_file) if migration_file else None,
+        markpact_files=[str(p) for p in (markpact_files or [])],
+        compose_files=[str(p) for p in (compose_files or [])],
+    )
+
+    return DeviceBlueprint(
+        name=name,
+        version=app_version,
+        description=description,
+        tags=tags or (device_map.tags if device_map else []),
+        services=services,
+        hardware=hw_req,
+        app_url=app_url,
+        deploy_strategy=deploy_strategy,
+        source=source,
+    )
+
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+def _merge_compose(path: Path, services: list[ServiceSpec], seen: set[str]) -> None:
+    """Parse a docker-compose YAML and merge service specs."""
+    try:
+        raw = yaml.safe_load(path.read_text())
+    except Exception:
+        return
+    if not isinstance(raw, dict) or "services" not in raw:
+        return
+
+    for svc_name, svc_def in raw["services"].items():
+        if not isinstance(svc_def, dict):
+            continue
+
+        # If already seen from InfraState, enrich rather than duplicate
+        existing = next((s for s in services if s.name == svc_name), None)
+        image = svc_def.get("image", "")
+        platform = svc_def.get("platform", "")
+        ports = _parse_compose_ports(svc_def.get("ports", []))
+        volumes = _parse_compose_volumes(svc_def.get("volumes", []))
+        env = _parse_compose_env(svc_def.get("environment", {}))
+        healthcheck = _parse_compose_healthcheck(svc_def.get("healthcheck", {}))
+        depends = svc_def.get("depends_on", [])
+        if isinstance(depends, dict):
+            depends = list(depends.keys())
+        command = svc_def.get("command", None)
+        if isinstance(command, list):
+            command = " ".join(str(c) for c in command)
+        restart = svc_def.get("restart", "unless-stopped")
+        privileged = bool(svc_def.get("privileged", False))
+
+        if existing:
+            if not existing.image and image:
+                existing.image = image
+            if not existing.platform and platform:
+                existing.platform = platform
+            if not existing.ports:
+                existing.ports = ports
+            if not existing.volumes:
+                existing.volumes = volumes
+            existing.env.update(env)
+            if not existing.healthcheck and healthcheck:
+                existing.healthcheck = healthcheck
+            if not existing.depends_on:
+                existing.depends_on = depends
+            existing.source_ref = str(path)
+        else:
+            seen.add(svc_name)
+            services.append(ServiceSpec(
+                name=svc_name,
+                image=image,
+                platform=platform,
+                ports=ports,
+                volumes=volumes,
+                env=env,
+                command=command,
+                healthcheck=healthcheck,
+                depends_on=depends,
+                restart=restart,
+                privileged=privileged,
+                source_ref=str(path),
+            ))
+
+
+def _parse_compose_ports(raw: list) -> list[ServicePort]:
+    result = []
+    for entry in raw:
+        if isinstance(entry, int):
+            result.append(ServicePort(host=entry, container=entry))
+        elif isinstance(entry, str):
+            # "8080:80/tcp"
+            m = re.match(r"(?:[\d.]+:)?(\d+):(\d+)(?:/(tcp|udp))?", entry)
+            if m:
+                result.append(ServicePort(
+                    host=int(m.group(1)),
+                    container=int(m.group(2)),
+                    protocol=m.group(3) or "tcp",
+                ))
+        elif isinstance(entry, dict):
+            result.append(ServicePort(
+                host=int(entry.get("published", entry.get("target", 0))),
+                container=int(entry.get("target", 0)),
+                protocol=entry.get("protocol", "tcp"),
+            ))
+    return result
+
+
+def _parse_compose_volumes(raw: list | dict) -> list[VolumeMount]:
+    result = []
+    items = raw if isinstance(raw, list) else [f"{k}:{v}" for k, v in raw.items()]
+    for entry in items:
+        if isinstance(entry, str) and ":" in entry:
+            parts = entry.split(":")
+            result.append(VolumeMount(
+                host=parts[0],
+                container=parts[1],
+                read_only=len(parts) > 2 and "ro" in parts[2],
+            ))
+        elif isinstance(entry, dict):
+            result.append(VolumeMount(
+                host=entry.get("source", ""),
+                container=entry.get("target", ""),
+                read_only=entry.get("read_only", False),
+            ))
+    return result
+
+
+def _parse_compose_env(raw: dict | list) -> dict[str, str]:
+    if isinstance(raw, dict):
+        return {str(k): str(v) for k, v in raw.items() if v is not None}
+    result = {}
+    for entry in raw:
+        if isinstance(entry, str) and "=" in entry:
+            k, _, v = entry.partition("=")
+            result[k.strip()] = v.strip()
+    return result
+
+
+def _parse_compose_healthcheck(raw: dict) -> Optional[str]:
+    if not raw:
+        return None
+    test = raw.get("test", [])
+    if isinstance(test, list) and len(test) > 1:
+        return " ".join(str(t) for t in test[1:])
+    if isinstance(test, str):
+        return test
+    return None
+
+
+def _parse_migration_meta(path: Path) -> dict:
+    try:
+        raw = yaml.safe_load(path.read_text())
+    except Exception:
+        return {}
+    if not isinstance(raw, dict):
+        return {}
+    result = {}
+    if "version" in raw:
+        result["version"] = str(raw["version"])
+    if "strategy" in raw:
+        result["strategy"] = raw["strategy"]
+    # Walk steps looking for deploy action to infer strategy
+    for step in raw.get("steps", []):
+        action = step.get("action", "")
+        if "podman" in action or "quadlet" in action:
+            result["strategy"] = "podman_quadlet"
+            break
+        if "docker" in action:
+            result["strategy"] = "docker_compose"
+            break
+    return result
+
+
+def _build_hw_requirements(hw) -> HardwareRequirements:
+    if hw is None:
+        return HardwareRequirements()
+
+    display_type = None
+    display_res = None
+    features: list[str] = []
+
+    # DRM / DSI
+    for output in getattr(hw, "drm_outputs", []):
+        if "DSI" in (output.connector or ""):
+            display_type = "DSI"
+            if output.modes:
+                display_res = output.modes[0]
+
+    if getattr(hw, "backlights", []):
+        features.append("backlight")
+    if getattr(hw, "i2c_buses", []):
+        features.append("i2c")
+
+    # Infer arch from board name
+    board = getattr(hw, "board", "") or ""
+    arch = "linux/arm64" if any(x in board.lower() for x in ("rpi", "raspberry", "aarch64", "pi")) else ""
+
+    # Overlays → wayland / kiosk hints
+    for overlay in getattr(hw, "dsi_overlays", []):
+        if "dsi" in overlay.lower():
+            features.append("wayland")
+
+    return HardwareRequirements(
+        arch=arch,
+        display_type=display_type,
+        display_resolution=display_res,
+        i2c_required=bool(getattr(hw, "i2c_buses", [])),
+        features=features,
+    )

redeploy-0.2.35/redeploy/blueprint/generators/docker_compose.py

@@ -0,0 +1,190 @@
+"""Generate a docker-compose.twin.yml for local digital-twin testing.
+
+The twin runs the full stack on the developer's machine (typically amd64),
+replacing platform-specific images where needed and mocking hardware
+dependencies (display, I2C, GPIO) via environment variables and stub
+containers.
+
+Usage::
+
+    from redeploy.blueprint.generators.docker_compose import generate_twin
+    compose_yaml = generate_twin(blueprint)
+"""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+import yaml
+
+from ...models import DeviceBlueprint, ServiceSpec
+
+# ── Platform remap table ───────────────────────────────────────────────────────
+# If the original image has no known amd64 variant we annotate it.
+_ARM_ONLY_PREFIXES = ("balena/", "resin/", "raspberrypi")
+
+
+def generate_twin(
+    blueprint: DeviceBlueprint,
+    *,
+    local_platform: str = "linux/amd64",
+    port_offset: int = 0,
+    network_name: str = "twin",
+    compose_version: str = "3.8",
+    add_mock_display: bool = True,
+    env_overrides: dict[str, str] | None = None,
+) -> str:
+    """Render a docker-compose YAML string for a local digital-twin.
+
+    Parameters
+    ----------
+    blueprint:
+        Source DeviceBlueprint extracted from the real device.
+    local_platform:
+        Target platform for the twin (default ``linux/amd64``).
+    port_offset:
+        Add this offset to all host ports to avoid conflicts, e.g. ``10000``.
+    network_name:
+        Docker network name for the twin stack.
+    add_mock_display:
+        If the blueprint requires a DSI display, inject a headless Xvfb
+        stub so the UI container has a framebuffer to connect to.
+    env_overrides:
+        Extra env vars to inject into every service (e.g. ``TWIN=1``).
+    """
+    services: dict[str, Any] = {}
+
+    for svc in blueprint.services:
+        svc_def = _build_service(
+            svc,
+            local_platform=local_platform,
+            port_offset=port_offset,
+            env_overrides=env_overrides or {},
+            twin_network=network_name,
+        )
+        services[svc.name] = svc_def
+
+    # Mock display stub
+    if add_mock_display and blueprint.hardware.display_type in ("DSI", "HDMI"):
+        res = blueprint.hardware.display_resolution or "1280x800"
+        w, _, h = res.partition("x")
+        services["_mock_display"] = {
+            "image": "jlesage/xvfb:latest",
+            "platform": local_platform,
+            "environment": {
+                "DISPLAY_WIDTH": w or "1280",
+                "DISPLAY_HEIGHT": h or "800",
+                "DISPLAY": ":99",
+            },
+            "networks": [network_name],
+            "profiles": ["mock"],         # only started with --profile mock
+            "labels": {"twin.role": "mock-display"},
+        }
+
+    # Compose document
+    doc: dict[str, Any] = {
+        "# Generated by redeploy blueprint twin": None,
+        "# Source blueprint": blueprint.name,
+        "# Original device": blueprint.source.device_id or "unknown",
+    }
+
+    compose: dict[str, Any] = {
+        "version": compose_version,
+        "services": services,
+        "networks": {
+            network_name: {"driver": "bridge"},
+        },
+    }
+
+    # Render: comments first (not directly supported by yaml.dump — use a header)
+    header = (
+        f"# Generated by redeploy blueprint twin\n"
+        f"# Source blueprint : {blueprint.name} v{blueprint.version}\n"
+        f"# Original device  : {blueprint.source.device_id or 'unknown'}\n"
+        f"# Original platform: {blueprint.hardware.arch or 'unknown'}\n"
+        f"# Twin platform    : {local_platform}\n"
+        f"#\n"
+        f"# Start with:  docker compose -f docker-compose.twin.yml up\n"
+        f"# With mocks:  docker compose -f docker-compose.twin.yml --profile mock up\n\n"
+    )
+    body = yaml.dump(compose, allow_unicode=True, sort_keys=False, default_flow_style=False)
+    return header + body
+
+
+def _build_service(
+    svc: ServiceSpec,
+    *,
+    local_platform: str,
+    port_offset: int,
+    env_overrides: dict[str, str],
+    twin_network: str,
+) -> dict[str, Any]:
+    d: dict[str, Any] = {}
+
+    # Image — keep original; add platform override
+    d["image"] = svc.image or "scratch"
+    if local_platform:
+        d["platform"] = local_platform
+
+    # Ports — apply offset if non-zero
+    if svc.ports:
+        port_list = []
+        for p in svc.ports:
+            host_port = p.host + port_offset
+            entry = f"{host_port}:{p.container}"
+            if p.protocol != "tcp":
+                entry += f"/{p.protocol}"
+            port_list.append(entry)
+        d["ports"] = port_list
+
+    # Volumes — swap absolute host paths to named volumes for portability
+    if svc.volumes:
+        vols = []
+        named: dict[str, Any] = {}
+        for v in svc.volumes:
+            if v.host.startswith("/"):
+                vol_name = re.sub(r"[^a-zA-Z0-9_]", "_", v.host.strip("/")) or "data"
+                vols.append(f"{vol_name}:{v.container}" + (":ro" if v.read_only else ""))
+                named[vol_name] = {"driver": "local"}
+            else:
+                vols.append(f"{v.host}:{v.container}" + (":ro" if v.read_only else ""))
+        d["volumes"] = vols
+        if named:
+            d["_named_volumes"] = named   # caller merges into top-level volumes
+
+    # Environment — original + twin overrides
+    env = dict(svc.env)
+    env["TWIN"] = "1"
+    env["DIGITAL_TWIN_SOURCE"] = svc.source_ref or "blueprint"
+    env.update(env_overrides)
+    # Redact secrets for display (keep them for actual use)
+    if env:
+        d["environment"] = env
+
+    # Hardware stubs — replace real device paths with no-ops
+    if svc.privileged:
+        # drop privilege in twin — could break some things, user can override
+        d["# privileged"] = "true (removed in twin — re-add if needed)"
+    else:
+        d["privileged"] = False
+
+    if svc.command:
+        d["command"] = svc.command
+
+    if svc.restart:
+        d["restart"] = svc.restart
+
+    if svc.depends_on:
+        d["depends_on"] = svc.depends_on
+
+    d["networks"] = [twin_network]
+
+    if svc.healthcheck:
+        d["healthcheck"] = {
+            "test": ["CMD-SHELL", svc.healthcheck],
+            "interval": "10s",
+            "timeout": "5s",
+            "retries": 3,
+        }
+
+    return d