daedalux 0.7.1__tar.gz

daedalux-0.7.1/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: daedalux
+Version: 0.7.1
+Summary: Package any app into a single self-extracting binary (release launcher)
+License: MIT
+Keywords: packaging,binary,self-extracting,static
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# daedalus (PyPI)
+
+`pip install daedalux` installs the `daedalus` CLI - it packages any app into
+a single self-extracting binary.
+
+```bash
+pip install daedalux
+daedalus build ./my-app -o my-app.de
+./my-app.de
+```
+
+The wheel ships a thin launcher: on first run it downloads the matching
+release binary from GitHub (SHA-256 verified against the release
+`checksums.txt`), caches it under `~/.cache/daedalus/pip/`, and execs it.
+Subsequent runs are a cache hit. No compilation, no sudo - the `daedalus-stub`
+and `daedalus-crypto` tools ship in the same download, so `daedalus build`
+works immediately.
+
+Platforms with release assets: Linux/macOS/Windows × amd64/arm64.
+`pip install daedalux --upgrade` releases the launcher; run any `daedalus`
+command once to pull a newer binary.

daedalux-0.7.1/README.md

@@ -0,0 +1,21 @@
+# daedalus (PyPI)
+
+`pip install daedalux` installs the `daedalus` CLI - it packages any app into
+a single self-extracting binary.
+
+```bash
+pip install daedalux
+daedalus build ./my-app -o my-app.de
+./my-app.de
+```
+
+The wheel ships a thin launcher: on first run it downloads the matching
+release binary from GitHub (SHA-256 verified against the release
+`checksums.txt`), caches it under `~/.cache/daedalus/pip/`, and execs it.
+Subsequent runs are a cache hit. No compilation, no sudo - the `daedalus-stub`
+and `daedalus-crypto` tools ship in the same download, so `daedalus build`
+works immediately.
+
+Platforms with release assets: Linux/macOS/Windows × amd64/arm64.
+`pip install daedalux --upgrade` releases the launcher; run any `daedalus`
+command once to pull a newer binary.

daedalux-0.7.1/daedalus/__init__.py

@@ -0,0 +1,7 @@
+"""daedalus - package any app into a single self-extracting binary."""
+
+from .launcher import VERSION, main
+
+__version__ = VERSION
+
+__all__ = ["VERSION", "main"]

daedalux-0.7.1/daedalus/launcher.py

@@ -0,0 +1,158 @@
+# pip release launcher for daedalus.
+#
+# pip/yarn-style native binaries cannot be shipped as wheels from a Rust
+# release flow, so this package installs a thin console script that resolves
+# the matching GitHub release tarball (checksum-verified) into a user cache
+# and execs the real daedalus binary. Every run is a cache hit after the
+# first download. See `daedalus-cli/src/release.rs` for the same logic in the
+# Rust CLI.
+"""daedalus release launcher."""
+
+import hashlib
+import io
+import os
+import platform
+import stat
+import sys
+import tarfile
+import urllib.request
+from dataclasses import dataclass
+from pathlib import Path
+
+VERSION = "0.7.1"
+REPO = "Encapsul/daedalus"
+CACHE_DIR = Path.home() / ".cache" / "daedalus" / "pip"
+MAX_TARBALL_BYTES = 200 * 1024 * 1024
+
+
+@dataclass
+class Platform:
+    os: str
+    arch: str
+
+
+def detect_platform() -> Platform:
+    """Map the running host to the (os, arch) tags used in release asset names."""
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    os_map = {"linux": "linux", "darwin": "darwin", "windows": "windows"}
+    if system not in os_map:
+        raise SystemExit(f"daedalus: unsupported platform: {platform.system()}")
+
+    if machine in ("x86_64", "amd64"):
+        arch = "amd64"
+    elif machine in ("aarch64", "arm64"):
+        arch = "arm64"
+    else:
+        raise SystemExit(f"daedalus: unsupported architecture: {platform.machine()}")
+
+    return Platform(os_map[system], arch)
+
+
+def release_url(p: Platform) -> str:
+    """GitHub release download URL for this platform's asset."""
+    asset = f"daedalus_{VERSION}_{p.os}_{p.arch}.tar.gz"
+    return f"https://github.com/{REPO}/releases/download/v{VERSION}/{asset}"
+
+
+def sha256_bytes(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def fetch_text(url: str) -> str:
+    with urllib.request.urlopen(url, timeout=30) as resp:
+        return resp.read().decode("utf-8")
+
+
+def expected_checksum(p: Platform) -> str:
+    """Fetch the sha256 for this asset from the release checksums.txt."""
+    checksums_url = f"https://github.com/{REPO}/releases/download/v{VERSION}/checksums.txt"
+    asset = f"daedalus_{VERSION}_{p.os}_{p.arch}.tar.gz"
+    return parse_checksums(fetch_text(checksums_url), asset)
+
+
+def parse_checksums(text: str, asset: str) -> str:
+    """Return the sha256 for `asset` from a release checksums.txt body."""
+    for line in text.splitlines():
+        parts = line.split()
+        if len(parts) >= 2 and parts[1].lstrip("*") == asset:
+            return parts[0]
+    raise SystemExit(f"daedalus: no checksum for {asset} in release checksums.txt")
+
+
+def download_verified(url: str, expected: str) -> bytes:
+    """Download a release asset, rejecting oversized or unverified payloads."""
+    with urllib.request.urlopen(url, timeout=600) as resp:
+        data = resp.read()
+    if len(data) > MAX_TARBALL_BYTES:
+        raise SystemExit(f"daedalus: release asset too large: {len(data)} bytes")
+    got = sha256_bytes(data)
+    if got != expected:
+        raise SystemExit(
+            f"daedalus: checksum mismatch for {url}: expected {expected}, got {got}"
+        )
+    return data
+
+
+def extract_daedalus(data: bytes, dest: Path) -> Path:
+    """Unpack the release tarball (daedalus + stub + crypto) into dest.
+
+    The Rust CLI resolves `daedalus-stub` next to the `daedalus` binary, so
+    all three release binaries are materialised in the cache directory."""
+    dest.mkdir(parents=True, exist_ok=True)
+    extracted = None
+    with tarfile.open(fileobj=io.BytesIO(data), mode="r:gz") as tar:
+        for member in tar.getmembers():
+            name = Path(member.name)
+            if ".." in name.parts:
+                raise SystemExit(f"daedalus: unsafe path in archive: {member.name}")
+            base = name.name
+            if not name.parent.name.startswith("daedalus_"):
+                continue
+            stem = base[:-4] if base.endswith(".exe") else base
+            if stem not in ("daedalus", "daedalus-stub", "daedalus-crypto"):
+                continue
+            if not member.isfile():
+                continue
+            f = tar.extractfile(member)
+            if f is None:
+                continue
+            target = dest / base
+            target.write_bytes(f.read())
+            if os.name != "nt":
+                target.chmod(target.stat().st_mode | stat.S_IXUSR)
+            if stem == "daedalus":
+                extracted = target
+    if extracted is None:
+        raise SystemExit("daedalus: did not find daedalus binary in release archive")
+    return extracted
+
+
+def cache_dir() -> Path:
+    return CACHE_DIR / VERSION / f"{detect_platform().os}_{detect_platform().arch}"
+
+
+def resolve_binary() -> Path:
+    """Return the cached daedalus binary, downloading it on first use."""
+    p = detect_platform()
+    where = cache_dir()
+    binary = where / "daedalus.exe" if os.name == "nt" else where / "daedalus"
+    if binary.exists():
+        return binary
+
+    url = release_url(p)
+    sys.stderr.write(f"[daedalus] downloading {url}...\n")
+    expected = expected_checksum(p)
+    data = download_verified(url, expected)
+    extracted = extract_daedalus(data, where)
+    return extracted
+
+
+def main() -> int:
+    binary = resolve_binary()
+    os.execv(str(binary), [str(binary)] + sys.argv[1:])
+
+
+if __name__ == "__main__":
+    sys.exit(main())

daedalux-0.7.1/daedalux.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: daedalux
+Version: 0.7.1
+Summary: Package any app into a single self-extracting binary (release launcher)
+License: MIT
+Keywords: packaging,binary,self-extracting,static
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# daedalus (PyPI)
+
+`pip install daedalux` installs the `daedalus` CLI - it packages any app into
+a single self-extracting binary.
+
+```bash
+pip install daedalux
+daedalus build ./my-app -o my-app.de
+./my-app.de
+```
+
+The wheel ships a thin launcher: on first run it downloads the matching
+release binary from GitHub (SHA-256 verified against the release
+`checksums.txt`), caches it under `~/.cache/daedalus/pip/`, and execs it.
+Subsequent runs are a cache hit. No compilation, no sudo - the `daedalus-stub`
+and `daedalus-crypto` tools ship in the same download, so `daedalus build`
+works immediately.
+
+Platforms with release assets: Linux/macOS/Windows × amd64/arm64.
+`pip install daedalux --upgrade` releases the launcher; run any `daedalus`
+command once to pull a newer binary.

daedalux-0.7.1/daedalux.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+daedalus/__init__.py
+daedalus/launcher.py
+daedalux.egg-info/PKG-INFO
+daedalux.egg-info/SOURCES.txt
+daedalux.egg-info/dependency_links.txt
+daedalux.egg-info/entry_points.txt
+daedalux.egg-info/top_level.txt
+tests/test_launcher.py

daedalux-0.7.1/daedalux.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

daedalux-0.7.1/daedalux.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+daedalus = daedalus.launcher:main

daedalux-0.7.1/daedalux.egg-info/top_level.txt

@@ -0,0 +1 @@
+daedalus

daedalux-0.7.1/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "daedalux"
+version = "0.7.1"
+description = "Package any app into a single self-extracting binary (release launcher)"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+keywords = ["packaging", "binary", "self-extracting", "static"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+    "License :: OSI Approved :: MIT License",
+]
+
+[project.scripts]
+daedalus = "daedalus.launcher:main"
+
+[tool.setuptools]
+packages = ["daedalus"]

daedalux-0.7.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

daedalux-0.7.1/tests/test_launcher.py

@@ -0,0 +1,107 @@
+"""Unit tests for the daedalus pip launcher (no network, no pip deps)."""
+
+import io
+import os
+import sys
+import tarfile
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from daedalus import launcher
+
+
+def make_tarball(files: dict[str, bytes]) -> bytes:
+    """Build an in-memory gzipped tarball mirroring a release archive layout."""
+    buf = io.BytesIO()
+    with tarfile.open(fileobj=buf, mode="w:gz") as tar:
+        for name, content in files.items():
+            info = tarfile.TarInfo(name)
+            info.size = len(content)
+            tar.addfile(info, io.BytesIO(content))
+    return buf.getvalue()
+
+
+class DetectPlatformTest(unittest.TestCase):
+    def test_known_host_maps(self):
+        # macOS amd64 shorthand is covered; Windows via sys.platform is hard to
+        # fake, so just assert the struct is well-formed on the running host.
+        p = launcher.detect_platform()
+        self.assertIn(p.os, ("linux", "darwin", "windows"))
+        self.assertIn(p.arch, ("amd64", "arm64"))
+
+    def test_asset_name(self):
+        p = launcher.Platform("darwin", "amd64")
+        self.assertEqual(
+            launcher.release_url(p).rsplit("/", 1)[-1],
+            f"daedalus_{launcher.VERSION}_darwin_amd64.tar.gz",
+        )
+
+
+class ChecksumTest(unittest.TestCase):
+    def test_sha256(self):
+        self.assertEqual(
+            launcher.sha256_bytes(b"hello world"),
+            "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
+        )
+
+    def test_expected_checksum_parse(self):
+        lines = "".join([
+            f"foo  daedalus_{launcher.VERSION}_darwin_amd64.tar.gz\n",
+            f"bar  daedalus_{launcher.VERSION}_darwin_arm64.tar.gz\n",
+        ])
+        self.assertEqual(
+            launcher.parse_checksums(
+                lines, f"daedalus_{launcher.VERSION}_darwin_arm64.tar.gz"
+            ),
+            "bar",
+        )
+
+    def test_parse_missing_asset_fails(self):
+        with self.assertRaises(SystemExit):
+            launcher.parse_checksums("x  nope.tar.gz\n", "daedalus_missing")
+
+
+class ExtractTest(unittest.TestCase):
+    def test_extract_full_archive(self):
+        content = make_tarball({
+            "daedalus_0.7.1_darwin_amd64/daedalus": b"\x7fELFfake",
+            "daedalus_0.7.1_darwin_amd64/daedalus-stub": b"\x7fELFstub",
+            "daedalus_0.7.1_darwin_amd64/daedalus-crypto": b"crypto",
+        })
+        with tempfile.TemporaryDirectory() as td:
+            dest = Path(td)
+            binary = launcher.extract_daedalus(content, dest)
+            self.assertEqual(binary, dest / "daedalus")
+            self.assertEqual((dest / "daedalus").read_bytes(), b"\x7fELFfake")
+            self.assertEqual((dest / "daedalus-stub").read_bytes(), b"\x7fELFstub")
+            self.assertEqual((dest / "daedalus-crypto").read_bytes(), b"crypto")
+
+    def test_extract_windows_exe(self):
+        content = make_tarball({
+            "daedalus_0.7.1_windows_amd64/daedalus.exe": b"MZexe",
+            "daedalus_0.7.1_windows_amd64/daedalus-stub.exe": b"MZstub",
+            "daedalus_0.7.1_windows_amd64/daedalus-crypto.exe": b"MZcrypto",
+        })
+        with tempfile.TemporaryDirectory() as td:
+            dest = Path(td)
+            binary = launcher.extract_daedalus(content, dest)
+            self.assertEqual(binary, dest / "daedalus.exe")
+
+    def test_extract_missing_binary_fails(self):
+        content = make_tarball({"daedalus_0.7.1_darwin_amd64/README": b"nope"})
+        with tempfile.TemporaryDirectory() as td:
+            with self.assertRaises(SystemExit):
+                launcher.extract_daedalus(content, Path(td))
+
+    def test_unsafe_path_rejected(self):
+        content = make_tarball({"daedalus_0.7.1_darwin_amd64/../../evil": b"x"})
+        with tempfile.TemporaryDirectory() as td:
+            with self.assertRaises(SystemExit):
+                launcher.extract_daedalus(content, Path(td))
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)