runpane 2.2.9__py3-none-any.whl

runpane/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.2.9"

runpane/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

runpane/cli.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from .doctor import run_doctor
+from .download import download_artifact
+from .installers import (
+    install_pane_artifact,
+    launch_pane_client,
+    resolve_existing_pane_path,
+    should_reuse_existing_pane,
+    spawn_pane,
+)
+from .platforms import detect_platform
+from .releases import resolve_release
+from .version import print_version
+
+SOURCE = "pip"
+
+COMMANDS = {"help", "install", "update", "version", "doctor"}
+TARGETS = {"client", "daemon"}
+FORMATS = {"auto", "appimage", "deb", "dmg", "zip", "exe"}
+CHANNELS = {"stable", "nightly"}
+
+REMOTE_VALUE_FLAGS = {
+    "--label",
+    "--prefer-tunnel",
+    "--channel",
+    "--base-url",
+    "--pane-dir",
+    "--listen-port",
+    "--port",
+    "--repo-ref",
+}
+
+REMOTE_BOOLEAN_FLAGS = {
+    "--auto-listen-port",
+    "--interactive-tailscale-setup",
+    "--no-install-service",
+    "--no-tailscale-serve",
+    "--print-only",
+}
+
+
+@dataclass
+class ParsedArgs:
+    command: str
+    target: str = "client"
+    pane_version: str = "latest"
+    channel: str = "stable"
+    format: str = "auto"
+    download_dir: Optional[str] = None
+    pane_path: Optional[str] = None
+    dry_run: bool = False
+    yes: bool = False
+    verbose: bool = False
+    help_topic: Optional[str] = None
+    remote_setup_args: List[str] = field(default_factory=list)
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    import sys
+
+    try:
+        parsed = parse_args(sys.argv[1:] if argv is None else argv)
+        if parsed.command == "help":
+            print(help_text(parsed.help_topic))
+            return 0
+        if parsed.command == "version":
+            return print_version(parsed.pane_path)
+        if parsed.command == "doctor":
+            return run_doctor(parsed, SOURCE)
+        if parsed.command in {"install", "update"}:
+            return install_or_update(parsed)
+        print(help_text(None))
+        return 0
+    except Exception as error:
+        print(str(error), file=sys.stderr)
+        return 1
+
+
+def parse_args(argv: List[str]) -> ParsedArgs:
+    args = list(argv)
+    if not args or args[0] in {"-h", "--help"}:
+        return ParsedArgs(command="help")
+    first = args.pop(0)
+    if first in {"-v", "--version"}:
+        return ParsedArgs(command="version")
+    if first not in COMMANDS:
+        raise ValueError(f"Unknown command: {first}\n\n{help_text(None)}")
+    if first == "help":
+        return ParsedArgs(command="help", help_topic=args[0] if args else None)
+
+    parsed = ParsedArgs(command=first)
+    if parsed.command == "install" and args and not args[0].startswith("-"):
+        target = args.pop(0)
+        if target not in TARGETS:
+            raise ValueError(f'Unknown install target: {target}. Expected "client" or "daemon".')
+        parsed.target = target
+
+    if parsed.command == "update":
+        parsed.target = "client"
+
+    parse_flags(args, parsed)
+    return parsed
+
+
+def parse_flags(args: List[str], parsed: ParsedArgs) -> None:
+    index = 0
+    while index < len(args):
+        arg = args[index]
+        if arg in {"-h", "--help"}:
+            parsed.help_topic = parsed.command
+            parsed.command = "help"
+        elif arg == "--dry-run":
+            parsed.dry_run = True
+        elif arg in {"--yes", "-y"}:
+            parsed.yes = True
+        elif arg == "--verbose":
+            parsed.verbose = True
+        elif arg == "--version":
+            index += 1
+            parsed.pane_version = read_value(args, index, arg)
+        elif arg == "--download-dir":
+            index += 1
+            parsed.download_dir = read_value(args, index, arg)
+        elif arg == "--pane-path":
+            index += 1
+            parsed.pane_path = read_value(args, index, arg)
+        elif arg == "--format":
+            index += 1
+            value = read_value(args, index, arg)
+            if value not in FORMATS:
+                raise ValueError(f"Invalid --format {value}. Expected one of: {', '.join(sorted(FORMATS))}")
+            parsed.format = value
+        elif arg in REMOTE_VALUE_FLAGS:
+            index += 1
+            value = read_value(args, index, arg)
+            if arg == "--channel":
+                if value not in CHANNELS:
+                    raise ValueError(f"Invalid --channel {value}. Expected stable or nightly.")
+                parsed.channel = value
+            append_remote_arg(parsed, arg, value)
+        elif arg in REMOTE_BOOLEAN_FLAGS:
+            append_remote_arg(parsed, arg)
+        elif parsed.command == "install" and parsed.target == "daemon":
+            parsed.remote_setup_args.append(arg)
+            if arg.startswith("-") and index + 1 < len(args) and not args[index + 1].startswith("-"):
+                index += 1
+                parsed.remote_setup_args.append(args[index])
+        else:
+            raise ValueError(f"Unknown option for {parsed.command}: {arg}")
+        index += 1
+
+
+def append_remote_arg(parsed: ParsedArgs, flag: str, value: Optional[str] = None) -> None:
+    if parsed.command == "install" and parsed.target == "daemon":
+        parsed.remote_setup_args.append(flag)
+        if value is not None:
+            parsed.remote_setup_args.append(value)
+        return
+    raise ValueError(f'{flag} is only valid with "runpane install daemon".')
+
+
+def read_value(args: List[str], index: int, flag: str) -> str:
+    if index >= len(args) or args[index].startswith("-"):
+        raise ValueError(f"{flag} requires a value.")
+    return args[index]
+
+
+def install_or_update(parsed: ParsedArgs) -> int:
+    target = "client" if parsed.command == "update" else parsed.target
+    if not parsed.dry_run and should_reuse_existing_pane(parsed, target):
+        existing = resolve_existing_pane_path(parsed.pane_path)
+        if existing:
+            return spawn_pane(existing, ["--remote-setup", *parsed.remote_setup_args])
+
+    platform = detect_platform()
+    resolved = resolve_release(
+        version=parsed.pane_version,
+        channel=parsed.channel,
+        source=SOURCE,
+        platform=platform,
+        format_name=parsed.format,
+        target=target,
+    )
+
+    if parsed.dry_run:
+        print("runpane dry run")
+        print(f"Command: {parsed.command}")
+        print(f"Target: {target}")
+        print(f"Pane release: {parsed.pane_version}")
+        print(f"Channel: {parsed.channel}")
+        print(f"Format: {parsed.format}")
+        print(f"Artifact: {resolved.artifact['name']}")
+        print(f"Preferred download: {resolved.preferred_download_url}")
+        print(f"GitHub fallback: {resolved.fallback_download_url}")
+        if parsed.pane_path:
+            print(f"Existing Pane path: {parsed.pane_path}")
+        if target == "daemon":
+            forwarded = " ".join(parsed.remote_setup_args)
+            print(f"Pane command: <pane executable> --remote-setup {forwarded}".strip())
+        return 0
+
+    artifact = download_artifact(resolved, parsed.download_dir, parsed.verbose)
+    installed = install_pane_artifact(artifact, parsed, platform, resolved.format, target)
+
+    if target == "daemon":
+        return spawn_pane(installed.executable_path, ["--remote-setup", *parsed.remote_setup_args])
+
+    if installed.install_kind == "installed":
+        launch_pane_client(installed.executable_path)
+
+    print(f"Pane {installed.install_kind}: {installed.executable_path}")
+    return 0
+
+
+def help_text(topic: Optional[str]) -> str:
+    if topic == "install":
+        return "\n".join([
+            "Usage:",
+            "  runpane install [client|daemon] [options]",
+            "",
+            "Examples:",
+            '  npx --yes runpane@latest install daemon --label "My Server"',
+            '  pnpm dlx runpane@latest install daemon --prefer-tunnel ssh --label "VM"',
+            '  pipx run runpane install daemon --label "My Server"',
+            "",
+            "Wrapper options:",
+            "  --version <latest|vX.Y.Z>",
+            "  --format <auto|appimage|deb|dmg|zip|exe>",
+            "  --download-dir <path>",
+            "  --pane-path <path>",
+            "  --dry-run",
+            "  --yes",
+            "  --verbose",
+            "",
+            "Daemon passthrough options:",
+            "  --label <name>",
+            "  --prefer-tunnel <tailscale|ssh|manual|auto>",
+            "  --channel <stable|nightly>",
+            "  --base-url <url>",
+            "  --pane-dir <path>",
+            "  --listen-port <port> / --port <port>",
+            "  --auto-listen-port",
+            "  --interactive-tailscale-setup",
+            "  --no-install-service",
+            "  --no-tailscale-serve",
+            "  --print-only",
+            "  --repo-ref <ref>",
+        ])
+
+    if topic == "update":
+        return "Usage:\n  runpane update [--version <latest|vX.Y.Z>] [--dry-run] [--yes]"
+    if topic == "version":
+        return "Usage:\n  runpane version\n  runpane --version"
+    if topic == "doctor":
+        return "Usage:\n  runpane doctor [--pane-path <path>] [--format <format>] [--verbose]"
+
+    return "\n".join([
+        "Usage:",
+        "  runpane install [client|daemon] [options]",
+        "  runpane update [options]",
+        "  runpane version",
+        "  runpane doctor",
+        "  runpane help [command]",
+        "",
+        "Package manager examples:",
+        '  pipx run runpane install daemon --label "My Server"',
+        '  uvx runpane@latest install daemon --label "My Server"',
+        '  python -m runpane install daemon --label "My Server"',
+        "",
+        'Run "runpane help install" for install options.',
+    ])

runpane/doctor.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from .installers import resolve_existing_pane_path
+from .platforms import detect_platform
+from .releases import resolve_release
+from .version import pane_version
+
+
+def run_doctor(parsed, source: str = "pip") -> int:
+    ok = True
+    try:
+        platform = detect_platform()
+        print(f"Platform: {platform.os}/{platform.arch}")
+        release = resolve_release(
+            version=parsed.pane_version,
+            channel=parsed.channel,
+            source=source,
+            platform=platform,
+            format_name=parsed.format,
+            target="client",
+        )
+        print(f"Latest release: {release.release['tag_name']}")
+        print(f"Selected artifact: {release.artifact['name']}")
+        print(f"Website URL: {release.preferred_download_url}")
+        print(f"GitHub fallback: {release.fallback_download_url}")
+    except Exception as error:
+        ok = False
+        print(f"Release check: failed - {error}")
+
+    installed = resolve_existing_pane_path(parsed.pane_path)
+    if installed:
+        print(f"Installed Pane: {installed}")
+        print(f"Installed version: {pane_version(installed) or 'unknown'}")
+    else:
+        print("Installed Pane: not found")
+
+    print('Remote setup: run "runpane install daemon --label <name>" to configure a headless host.')
+    return 0 if ok else 1

runpane/download.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+import tempfile
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from typing import Optional
+
+from .releases import ResolvedRelease, artifact_file_name
+
+
+@dataclass
+class DownloadedArtifact:
+    path: str
+    file_name: str
+    used_fallback: bool
+
+
+def download_artifact(resolved: ResolvedRelease, download_dir: Optional[str], verbose: bool) -> DownloadedArtifact:
+    target_dir = download_dir or os.path.join(tempfile.gettempdir(), f"runpane-{int(time.time() * 1000)}")
+    os.makedirs(target_dir, exist_ok=True)
+
+    file_name = artifact_file_name(resolved.artifact["name"])
+    target_path = os.path.join(target_dir, file_name)
+    used_fallback = False
+
+    try:
+        download_to_file(resolved.preferred_download_url, target_path, verbose)
+    except Exception as error:
+        used_fallback = True
+        print(f"runpane: website download route failed; falling back to GitHub release asset. {error}")
+        download_to_file(resolved.fallback_download_url, target_path, verbose)
+
+    verify_checksum_if_available(resolved, target_path, file_name)
+    return DownloadedArtifact(path=target_path, file_name=file_name, used_fallback=used_fallback)
+
+
+def download_to_file(url: str, target_path: str, verbose: bool) -> None:
+    if verbose:
+        print(f"Downloading {url}")
+    req = urllib.request.Request(url, headers={"User-Agent": "runpane-installer"})
+    with urllib.request.urlopen(req, timeout=120) as response:
+        if getattr(response, "status", 200) >= 400:
+            raise RuntimeError(f"{response.status} {response.reason}")
+        with open(target_path, "wb") as target:
+            shutil.copyfileobj(response, target, length=1024 * 1024)
+
+
+def verify_checksum_if_available(resolved: ResolvedRelease, artifact_path: str, file_name: str) -> None:
+    try:
+        req = urllib.request.Request(resolved.checksum_url, headers={"User-Agent": "runpane-installer"})
+        with urllib.request.urlopen(req, timeout=30) as response:
+            checksums = response.read().decode("utf-8")
+    except (urllib.error.URLError, TimeoutError, OSError) as error:
+        print(f"runpane: could not verify checksum for {file_name}. {error}")
+        return
+
+    expected = parse_checksum(checksums, file_name)
+    if not expected:
+        return
+
+    digest = hashlib.sha256()
+    with open(artifact_path, "rb") as source:
+        for chunk in iter(lambda: source.read(1024 * 1024), b""):
+            digest.update(chunk)
+
+    actual = digest.hexdigest()
+    if actual.lower() != expected.lower():
+        raise RuntimeError(f"Checksum mismatch for {file_name}. Expected {expected}, got {actual}.")
+
+
+def parse_checksum(checksums: str, file_name: str) -> Optional[str]:
+    for line in checksums.splitlines():
+        stripped = line.strip()
+        if not stripped.endswith(file_name):
+            continue
+        digest = stripped.split()[0]
+        if len(digest) == 64 and all(char in "0123456789abcdefABCDEF" for char in digest):
+            return digest
+    return None

runpane/installers.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import subprocess
+from dataclasses import dataclass
+from typing import List, Optional
+
+from .download import DownloadedArtifact
+from .platforms import PanePlatform, default_install_root
+
+
+@dataclass
+class InstalledPane:
+    executable_path: str
+    install_kind: str
+
+
+def resolve_existing_pane_path(pane_path: Optional[str] = None) -> Optional[str]:
+    if pane_path:
+        return pane_path if os.path.exists(pane_path) else None
+
+    home = os.path.expanduser("~")
+    candidates = []
+    if os.name == "nt":
+        local = os.environ.get("LOCALAPPDATA")
+        program_files = os.environ.get("ProgramFiles")
+        if local:
+            candidates.extend([
+                os.path.join(local, "Programs", "Pane", "Pane.exe"),
+                os.path.join(local, "Pane", "Pane.exe"),
+            ])
+        if program_files:
+            candidates.append(os.path.join(program_files, "Pane", "Pane.exe"))
+    elif platform.system().lower() == "darwin":
+        candidates.extend([
+            "/Applications/Pane.app/Contents/MacOS/Pane",
+            os.path.join(home, "Applications", "Pane.app", "Contents", "MacOS", "Pane"),
+        ])
+    else:
+        candidates.extend([
+            os.path.join(home, ".local", "bin", "pane"),
+            "/usr/bin/pane",
+            "/opt/Pane/pane",
+        ])
+
+    for candidate in candidates:
+        if os.path.exists(candidate):
+            return candidate
+    return None
+
+
+def should_reuse_existing_pane(parsed, target: str) -> bool:
+    return parsed.command == "install" and target == "daemon"
+
+
+def install_pane_artifact(
+    artifact: DownloadedArtifact,
+    parsed,
+    platform: PanePlatform,
+    format_name: str,
+    target: str,
+) -> InstalledPane:
+    existing = resolve_existing_pane_path(parsed.pane_path)
+    if existing and should_reuse_existing_pane(parsed, target):
+        return InstalledPane(executable_path=existing, install_kind="existing")
+
+    if platform.os == "darwin":
+        return install_mac(artifact, format_name, target)
+    if platform.os == "linux":
+        return install_linux(artifact, format_name)
+    return install_windows(artifact, target)
+
+
+def spawn_pane(executable_path: str, args: List[str]) -> int:
+    try:
+        return subprocess.call([executable_path, *args])
+    except OSError as error:
+        print(f"Failed to launch Pane: {error}")
+        return 1
+
+
+def launch_pane_client(executable_path: str) -> None:
+    subprocess.Popen([executable_path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
+
+
+def install_mac(artifact: DownloadedArtifact, format_name: str, target: str) -> InstalledPane:
+    if format_name == "dmg":
+        subprocess.call(["open", artifact.path])
+        return InstalledPane(executable_path="/Applications/Pane.app/Contents/MacOS/Pane", install_kind="launched-installer")
+
+    apps_root = os.path.join(os.path.expanduser("~"), "Applications")
+    app_path = os.path.join(apps_root, "Pane.app")
+    os.makedirs(apps_root, exist_ok=True)
+    subprocess.check_call(["ditto", "-x", "-k", artifact.path, apps_root])
+    executable_path = os.path.join(app_path, "Contents", "MacOS", "Pane")
+    if not os.path.exists(executable_path):
+        raise RuntimeError(f"Pane executable was not found after extracting {artifact.file_name}. Expected {executable_path}")
+    if target == "client":
+        subprocess.call(["open", app_path])
+    return InstalledPane(executable_path=executable_path, install_kind="installed")
+
+
+def install_linux(artifact: DownloadedArtifact, format_name: str) -> InstalledPane:
+    if format_name == "deb":
+        installer = "apt" if shutil.which("apt") else "dpkg"
+        args = ["install", "-y", artifact.path] if installer == "apt" else ["-i", artifact.path]
+        subprocess.call(["sudo", installer, *args])
+        executable = resolve_existing_pane_path()
+        if not executable:
+            raise RuntimeError("Pane installed from .deb, but the pane executable could not be found.")
+        return InstalledPane(executable_path=executable, install_kind="installed")
+
+    bin_root = default_install_root()
+    os.makedirs(bin_root, exist_ok=True)
+    executable_path = os.path.join(bin_root, "pane")
+    shutil.copyfile(artifact.path, executable_path)
+    os.chmod(executable_path, 0o755)
+    return InstalledPane(executable_path=executable_path, install_kind="installed")
+
+
+def install_windows(artifact: DownloadedArtifact, target: str) -> InstalledPane:
+    args = ["/S"] if target == "daemon" else []
+    subprocess.call([artifact.path, *args])
+    executable = resolve_existing_pane_path()
+    if not executable:
+        raise RuntimeError("Pane installer completed, but Pane.exe could not be found. Open the installer manually and rerun with --pane-path.")
+    return InstalledPane(executable_path=executable, install_kind="installed" if target == "daemon" else "launched-installer")

runpane/platforms.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import os
+import platform
+from dataclasses import dataclass
+from typing import List
+
+
+@dataclass(frozen=True)
+class PanePlatform:
+    os: str
+    arch: str
+
+
+def detect_platform() -> PanePlatform:
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    if system == "darwin":
+        os_name = "darwin"
+    elif system == "linux":
+        os_name = "linux"
+    elif system == "windows":
+        os_name = "win32"
+    else:
+        raise RuntimeError(f"Unsupported OS: {system}")
+
+    if machine in {"x86_64", "amd64"}:
+        arch = "x64"
+    elif machine in {"arm64", "aarch64"}:
+        arch = "arm64"
+    else:
+        raise RuntimeError(f"Unsupported CPU architecture: {machine}")
+
+    return PanePlatform(os=os_name, arch=arch)
+
+
+def default_format(platform_info: PanePlatform, target: str) -> str:
+    if platform_info.os == "darwin":
+        return "zip" if target == "daemon" else "dmg"
+    if platform_info.os == "win32":
+        return "exe"
+    return "appimage"
+
+
+def platform_param(platform_info: PanePlatform) -> str:
+    if platform_info.os == "darwin":
+        return "mac"
+    if platform_info.os == "win32":
+        return "windows"
+    return "linux"
+
+
+def arch_aliases(platform_info: PanePlatform) -> List[str]:
+    if platform_info.arch == "arm64":
+        return ["arm64", "aarch64"]
+    if platform_info.os == "linux":
+        return ["x64", "x86_64", "amd64"]
+    return ["x64", "x86_64"]
+
+
+def default_install_root() -> str:
+    if os.name == "nt":
+        return os.environ.get("LOCALAPPDATA", os.path.join(os.path.expanduser("~"), "AppData", "Local", "Pane"))
+    if platform.system().lower() == "darwin":
+        return os.path.join(os.path.expanduser("~"), "Applications")
+    return os.path.join(os.path.expanduser("~"), ".local", "bin")

runpane/releases.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from .platforms import PanePlatform, arch_aliases, default_format, platform_param
+
+GITHUB_API_BASE = "https://api.github.com/repos/dcouple/Pane/releases"
+DOWNLOAD_API_BASE = "https://runpane.com/api/download"
+
+
+@dataclass
+class ResolvedRelease:
+    release: Dict[str, Any]
+    artifact: Dict[str, Any]
+    format: str
+    preferred_download_url: str
+    fallback_download_url: str
+    checksum_url: str
+
+
+def resolve_release(
+    *,
+    version: str,
+    channel: str,
+    source: str,
+    platform: PanePlatform,
+    format_name: str,
+    target: str,
+) -> ResolvedRelease:
+    release = fetch_release(version)
+    selected_format = default_format(platform, target) if format_name == "auto" else format_name
+    artifact = find_artifact(release, platform, selected_format)
+    preferred = build_preferred_download_url(channel, source, platform, selected_format, release)
+    tag_name = release["tag_name"]
+    return ResolvedRelease(
+        release=release,
+        artifact=artifact,
+        format=selected_format,
+        preferred_download_url=preferred,
+        fallback_download_url=artifact["browser_download_url"],
+        checksum_url=f"https://github.com/dcouple/Pane/releases/download/{tag_name}/SHA256SUMS.txt",
+    )
+
+
+def fetch_release(version: str) -> Dict[str, Any]:
+    normalized = "latest" if version == "latest" else f"tags/{version if version.startswith('v') else 'v' + version}"
+    req = urllib.request.Request(
+        f"{GITHUB_API_BASE}/{normalized}",
+        headers={"Accept": "application/vnd.github+json", "User-Agent": "runpane-installer"},
+    )
+    with urllib.request.urlopen(req, timeout=30) as response:
+        release = json.loads(response.read().decode("utf-8"))
+
+    if release.get("draft") or release.get("prerelease"):
+        raise RuntimeError(f"Release {release.get('tag_name')} is not a stable public release.")
+    return release
+
+
+def find_artifact(release: Dict[str, Any], platform: PanePlatform, format_name: str) -> Dict[str, Any]:
+    assets = release.get("assets") or []
+    candidates = [
+        asset for asset in assets
+        if matches_format(asset["name"], format_name) and matches_platform(asset["name"], platform)
+    ]
+    aliases = arch_aliases(platform)
+    for asset in candidates:
+        lower = asset["name"].lower()
+        if any(alias.lower() in lower for alias in aliases):
+            return asset
+    for asset in candidates:
+        if "universal" in asset["name"].lower():
+            return asset
+    if candidates:
+        return candidates[0]
+    names = ", ".join(asset["name"] for asset in assets) or "no assets"
+    raise RuntimeError(f"No Pane {format_name} asset found for {platform.os}/{platform.arch}. Assets: {names}")
+
+
+def artifact_file_name(url_or_name: str) -> str:
+    return os.path.basename(url_or_name.split("?", 1)[0])
+
+
+def build_preferred_download_url(
+    channel: str,
+    source: str,
+    platform: PanePlatform,
+    format_name: str,
+    release: Dict[str, Any],
+) -> str:
+    query = urllib.parse.urlencode({
+        "platform": platform_param(platform),
+        "arch": platform.arch,
+        "format": format_name,
+        "version": release["tag_name"],
+        "channel": channel,
+        "source": source,
+    })
+    return f"{DOWNLOAD_API_BASE}?{query}"
+
+
+def matches_format(name: str, format_name: str) -> bool:
+    lower = name.lower()
+    if format_name == "appimage":
+        return lower.endswith(".appimage")
+    return lower.endswith(f".{format_name}")
+
+
+def matches_platform(name: str, platform: PanePlatform) -> bool:
+    lower = name.lower()
+    if platform.os == "darwin":
+        return "macos" in lower or "darwin" in lower or "mac" in lower
+    if platform.os == "win32":
+        return "windows" in lower or re.search(r"(?:^|[._-])win(?:32|64)?(?:[._-]|$)", lower) is not None
+    return "linux" in lower

runpane/version.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import subprocess
+from importlib import metadata
+from typing import Optional
+
+from . import __version__
+from .installers import resolve_existing_pane_path
+from .releases import fetch_release
+
+
+def wrapper_version() -> str:
+    try:
+        return metadata.version("runpane")
+    except metadata.PackageNotFoundError:
+        return __version__
+
+
+def print_version(pane_path: Optional[str] = None) -> int:
+    installed_path = resolve_existing_pane_path(pane_path)
+    installed_version = pane_version(installed_path) if installed_path else None
+    try:
+        latest = fetch_release("latest")["tag_name"].lstrip("v")
+    except Exception:
+        latest = "unavailable"
+
+    print(f"runpane {wrapper_version()}")
+    print(f"Pane installed: {installed_version or 'not found'}")
+    print(f"Pane latest: {latest}")
+    if installed_path:
+        print(f"Pane path: {installed_path}")
+    return 0
+
+
+def pane_version(executable_path: str) -> Optional[str]:
+    try:
+        result = subprocess.run([executable_path, "--version"], capture_output=True, text=True, timeout=10)
+    except OSError:
+        return None
+    output = (result.stdout + result.stderr).strip()
+    return output or None

runpane-2.2.9.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: runpane
+Version: 2.2.9
+Summary: Thin PyPI installer and remote setup CLI for Pane
+Author-email: Dcouple Inc <hello@dcouple.ai>
+License: AGPL-3.0
+Project-URL: Homepage, https://runpane.com
+Project-URL: Repository, https://github.com/dcouple/Pane
+Project-URL: Issues, https://github.com/dcouple/Pane/issues
+Keywords: pane,installer,remote,daemon,cli
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# runpane
+
+Thin PyPI installer and remote setup CLI for Pane.
+
+The package does not include the Pane desktop runtime. It downloads the correct
+Pane release artifact only when you run `runpane install` or `runpane update`.
+
+## Usage
+
+One-shot execution:
+
+```bash
+pipx run runpane install daemon --label "My Server"
+uvx runpane@latest install daemon --label "My Server"
+```
+
+Persistent install:
+
+```bash
+python -m pip install runpane
+runpane install daemon --label "My Server"
+
+pipx install runpane
+runpane install daemon --label "My Server"
+```
+
+Module entrypoint:
+
+```bash
+python -m runpane install daemon --label "My Server"
+```
+
+## Commands
+
+```bash
+runpane install
+runpane install client
+runpane install daemon
+runpane update
+runpane version
+runpane doctor
+runpane --help
+```
+
+`runpane install daemon` installs Pane and then invokes the installed executable
+with `--remote-setup`, preserving the `pane-remote://...` connection-code output.
+
+## Attribution
+
+PyPI package downloads use `source=pip` when requesting release artifacts from
+`runpane.com/api/download`. If that route is unavailable, the CLI falls back to
+matching GitHub release assets and prints a warning.
+
+## Publishing
+
+This package should be published through PyPI Trusted Publishing from GitHub
+Actions. Token-based `PYPI_API_TOKEN` publishing is a fallback for first package
+reservation or manual publication only.

runpane-2.2.9.dist-info/RECORD

@@ -0,0 +1,14 @@
+runpane/__init__.py,sha256=4yiQmg1jez9eDe7VvOU40EgTkcAYoip5MZXkPgQyf-I,22
+runpane/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+runpane/cli.py,sha256=tHOeW3o-wV-9DYUoyFGXvJhMA2SztSsz7iaR85jcm7w,9582
+runpane/doctor.py,sha256=72k4cQTYDSIBecBdpvlMhZBll3fxw09IuoxPXN3FPO0,1360
+runpane/download.py,sha256=QsLLIp92kYPYke7LrRuz-EZ9U3jjKA8OpF5H13l3JFw,3110
+runpane/installers.py,sha256=7Uc4e5WwYHAkN31upY6hj3JnN-pb8VydCO8o6GN1faM,4963
+runpane/platforms.py,sha256=pYtN7FE7iW4FB7GxFvSYabFfyIt0TU7GHunn3kbcBQw,1834
+runpane/releases.py,sha256=51nXU9rkEVf4acORl8-5_-AtsP1q86gMszL5BN6j248,4007
+runpane/version.py,sha256=1cFRGy1Ju7tpSc4RN5vH-bMnjGw0NTZvQQ4l44izloQ,1229
+runpane-2.2.9.dist-info/METADATA,sha256=4NgoSO6GpBnre_9-Z4S5FKd6hBJTZd5GmZKhAaOXYpk,2051
+runpane-2.2.9.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+runpane-2.2.9.dist-info/entry_points.txt,sha256=7R0nNreFQ5xeluCzoypdlcsk3bJm3a9r-Xgt1kj4ZPQ,45
+runpane-2.2.9.dist-info/top_level.txt,sha256=1I4gNmo6R1UAvbsmlTYzYVZvYZiZrKN9r3VfZDVPM7c,8
+runpane-2.2.9.dist-info/RECORD,,

runpane-2.2.9.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

runpane-2.2.9.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+runpane = runpane.cli:main

runpane-2.2.9.dist-info/top_level.txt

@@ -0,0 +1 @@
+runpane