droppass-cli 0.1.3__tar.gz

droppass_cli-0.1.3/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: droppass-cli
+Version: 0.1.3
+Summary: droppass CLI distributed via pip
+Author: AFK Surf
+License-Expression: LicenseRef-UNLICENSED
+Project-URL: Homepage, https://github.com/AFK-surf/droppass
+Project-URL: Repository, https://github.com/AFK-surf/droppass
+Keywords: droppass,cli,secrets,agent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# droppass-cli
+
+Install globally with pip:
+
+```bash
+pip install droppass-cli
+```
+
+The package ships a Python launcher plus prebuilt `droppass` binaries for the
+same targets as the standalone release assets:
+
+- `darwin-x64`
+- `darwin-arm64`
+- `linux-x64`
+- `linux-arm64`
+- `linux-arm`
+- `win32-x64`
+- `win32-arm64`
+
+The launcher selects the matching embedded binary at runtime.
+
+Maintainer release flow:
+
+```bash
+cd cli
+node ./scripts/build-pip-package.mjs
+python3 -m build --outdir ./dist/pip/dist ./dist/pip/package
+```
+
+CI publishes the package to PyPI from `v*` tags. See `cli/RELEASING.md`
+for the full release workflow.

droppass_cli-0.1.3/README.md

@@ -0,0 +1,31 @@
+# droppass-cli
+
+Install globally with pip:
+
+```bash
+pip install droppass-cli
+```
+
+The package ships a Python launcher plus prebuilt `droppass` binaries for the
+same targets as the standalone release assets:
+
+- `darwin-x64`
+- `darwin-arm64`
+- `linux-x64`
+- `linux-arm64`
+- `linux-arm`
+- `win32-x64`
+- `win32-arm64`
+
+The launcher selects the matching embedded binary at runtime.
+
+Maintainer release flow:
+
+```bash
+cd cli
+node ./scripts/build-pip-package.mjs
+python3 -m build --outdir ./dist/pip/dist ./dist/pip/package
+```
+
+CI publishes the package to PyPI from `v*` tags. See `cli/RELEASING.md`
+for the full release workflow.

droppass_cli-0.1.3/droppass_cli/__init__.py

@@ -0,0 +1,3 @@
+from ._version import __version__
+
+__all__ = ["__version__"]

droppass_cli-0.1.3/droppass_cli/__main__.py

@@ -0,0 +1,5 @@
+from .launcher import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

droppass_cli-0.1.3/droppass_cli/_version.py

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

droppass_cli-0.1.3/droppass_cli/launcher.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import os
+import platform
+import stat
+import subprocess
+import sys
+from importlib import resources
+
+TARGETS = {
+    "darwin-x64": {
+        "platform": "darwin",
+        "arch": "x64",
+        "binary_name": "droppass-darwin-x64",
+    },
+    "darwin-arm64": {
+        "platform": "darwin",
+        "arch": "arm64",
+        "binary_name": "droppass-darwin-arm64",
+    },
+    "linux-x64": {
+        "platform": "linux",
+        "arch": "x64",
+        "binary_name": "droppass-linux-x64",
+    },
+    "linux-arm64": {
+        "platform": "linux",
+        "arch": "arm64",
+        "binary_name": "droppass-linux-arm64",
+    },
+    "linux-arm": {
+        "platform": "linux",
+        "arch": "arm",
+        "binary_name": "droppass-linux-arm",
+    },
+    "win32-x64": {
+        "platform": "win32",
+        "arch": "x64",
+        "binary_name": "droppass-win32-x64.exe",
+    },
+    "win32-arm64": {
+        "platform": "win32",
+        "arch": "arm64",
+        "binary_name": "droppass-win32-arm64.exe",
+    },
+}
+
+
+def format_target(runtime_platform: str, runtime_arch: str) -> str:
+    return f"{runtime_platform}-{runtime_arch}"
+
+
+def detect_target() -> dict[str, str]:
+    runtime_platform = "win32" if sys.platform.startswith("win") else sys.platform
+    machine = platform.machine().lower()
+
+    if runtime_platform == "darwin":
+        runtime_arch = "arm64" if machine in {"arm64", "aarch64"} else "x64"
+    elif runtime_platform == "linux":
+        if machine in {"x86_64", "amd64"}:
+            runtime_arch = "x64"
+        elif machine in {"aarch64", "arm64"}:
+            runtime_arch = "arm64"
+        elif machine.startswith("armv7") or machine.startswith("armv6") or machine == "arm":
+            runtime_arch = "arm"
+        else:
+            runtime_arch = machine
+    elif runtime_platform == "win32":
+        if machine in {"arm64", "aarch64"}:
+            runtime_arch = "arm64"
+        else:
+            runtime_arch = "x64"
+    else:
+        runtime_arch = machine
+
+    key = format_target(runtime_platform, runtime_arch)
+    target = TARGETS.get(key)
+    if not target:
+        supported = ", ".join(sorted(TARGETS))
+        raise RuntimeError(f"Unsupported platform {key}. Supported targets: {supported}")
+    return target
+
+
+def resolve_binary_path() -> str:
+    target = detect_target()
+    binary = resources.files("droppass_cli").joinpath("bin", target["binary_name"])
+    if not binary.is_file():
+        raise RuntimeError(
+            f"Missing embedded binary {target['binary_name']} for "
+            f"{format_target(target['platform'], target['arch'])}."
+        )
+
+    path = os.fspath(binary)
+    if not path.endswith(".exe"):
+        mode = os.stat(path).st_mode
+        if not mode & stat.S_IXUSR:
+            os.chmod(path, mode | stat.S_IXUSR)
+    return path
+
+
+def main(argv: list[str] | None = None) -> int:
+    binary_path = resolve_binary_path()
+    completed = subprocess.run([binary_path, *(argv if argv is not None else sys.argv[1:])])
+    if completed.returncode < 0:
+        os.kill(os.getpid(), -completed.returncode)
+    return completed.returncode

droppass_cli-0.1.3/droppass_cli.egg-info/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: droppass-cli
+Version: 0.1.3
+Summary: droppass CLI distributed via pip
+Author: AFK Surf
+License-Expression: LicenseRef-UNLICENSED
+Project-URL: Homepage, https://github.com/AFK-surf/droppass
+Project-URL: Repository, https://github.com/AFK-surf/droppass
+Keywords: droppass,cli,secrets,agent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# droppass-cli
+
+Install globally with pip:
+
+```bash
+pip install droppass-cli
+```
+
+The package ships a Python launcher plus prebuilt `droppass` binaries for the
+same targets as the standalone release assets:
+
+- `darwin-x64`
+- `darwin-arm64`
+- `linux-x64`
+- `linux-arm64`
+- `linux-arm`
+- `win32-x64`
+- `win32-arm64`
+
+The launcher selects the matching embedded binary at runtime.
+
+Maintainer release flow:
+
+```bash
+cd cli
+node ./scripts/build-pip-package.mjs
+python3 -m build --outdir ./dist/pip/dist ./dist/pip/package
+```
+
+CI publishes the package to PyPI from `v*` tags. See `cli/RELEASING.md`
+for the full release workflow.

droppass_cli-0.1.3/droppass_cli.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+droppass_cli/__init__.py
+droppass_cli/__main__.py
+droppass_cli/_version.py
+droppass_cli/launcher.py
+droppass_cli.egg-info/PKG-INFO
+droppass_cli.egg-info/SOURCES.txt
+droppass_cli.egg-info/dependency_links.txt
+droppass_cli.egg-info/entry_points.txt
+droppass_cli.egg-info/top_level.txt
+droppass_cli/bin/droppass-darwin-arm64
+droppass_cli/bin/droppass-darwin-x64
+droppass_cli/bin/droppass-linux-arm
+droppass_cli/bin/droppass-linux-arm64
+droppass_cli/bin/droppass-linux-x64
+droppass_cli/bin/droppass-win32-arm64.exe
+droppass_cli/bin/droppass-win32-x64.exe
+tests/test_launcher.py

droppass_cli-0.1.3/droppass_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

droppass_cli-0.1.3/droppass_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+droppass = droppass_cli.__main__:main

droppass_cli-0.1.3/droppass_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+droppass_cli

droppass_cli-0.1.3/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "droppass-cli"
+version = "0.1.3"
+description = "droppass CLI distributed via pip"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "LicenseRef-UNLICENSED"
+keywords = ["droppass", "cli", "secrets", "agent"]
+authors = [{ name = "AFK Surf" }]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Operating System :: MacOS",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://github.com/AFK-surf/droppass"
+Repository = "https://github.com/AFK-surf/droppass"
+
+[project.scripts]
+droppass = "droppass_cli.__main__:main"
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+include = ["droppass_cli*"]
+
+[tool.setuptools.package-data]
+"droppass_cli" = ["bin/*"]

droppass_cli-0.1.3/setup.cfg

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

droppass_cli-0.1.3/tests/test_launcher.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import os
+import stat
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest import mock
+
+from droppass_cli import launcher
+
+
+class DetectTargetTests(unittest.TestCase):
+    def test_detect_target_linux_x64(self) -> None:
+        with (
+            mock.patch.object(launcher.sys, "platform", "linux"),
+            mock.patch.object(launcher.platform, "machine", return_value="x86_64"),
+        ):
+            target = launcher.detect_target()
+
+        self.assertEqual(target, launcher.TARGETS["linux-x64"])
+
+    def test_detect_target_linux_arm64(self) -> None:
+        with (
+            mock.patch.object(launcher.sys, "platform", "linux"),
+            mock.patch.object(launcher.platform, "machine", return_value="aarch64"),
+        ):
+            target = launcher.detect_target()
+
+        self.assertEqual(target, launcher.TARGETS["linux-arm64"])
+
+    def test_detect_target_windows_x64(self) -> None:
+        with (
+            mock.patch.object(launcher.sys, "platform", "win32"),
+            mock.patch.object(launcher.platform, "machine", return_value="AMD64"),
+        ):
+            target = launcher.detect_target()
+
+        self.assertEqual(target, launcher.TARGETS["win32-x64"])
+
+    def test_detect_target_unsupported_platform_raises(self) -> None:
+        with (
+            mock.patch.object(launcher.sys, "platform", "linux"),
+            mock.patch.object(launcher.platform, "machine", return_value="ppc64le"),
+        ):
+            with self.assertRaisesRegex(RuntimeError, "Unsupported platform linux-ppc64le"):
+                launcher.detect_target()
+
+
+class ResolveBinaryPathTests(unittest.TestCase):
+    def test_resolve_binary_path_sets_execute_bit(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            package_root = Path(temp_dir)
+            bin_dir = package_root / "bin"
+            bin_dir.mkdir(parents=True)
+            binary_path = bin_dir / "droppass-linux-x64"
+            binary_path.write_text("#!/bin/sh\nexit 0\n", encoding="utf-8")
+            binary_path.chmod(0o644)
+
+            with (
+                mock.patch.object(launcher, "detect_target", return_value=launcher.TARGETS["linux-x64"]),
+                mock.patch.object(launcher.resources, "files", return_value=package_root),
+            ):
+                resolved = launcher.resolve_binary_path()
+
+            self.assertEqual(resolved, os.fspath(binary_path))
+            self.assertTrue(os.stat(resolved).st_mode & stat.S_IXUSR)
+
+    def test_resolve_binary_path_missing_binary_raises(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            package_root = Path(temp_dir)
+
+            with (
+                mock.patch.object(launcher, "detect_target", return_value=launcher.TARGETS["linux-x64"]),
+                mock.patch.object(launcher.resources, "files", return_value=package_root),
+            ):
+                with self.assertRaisesRegex(RuntimeError, "Missing embedded binary droppass-linux-x64"):
+                    launcher.resolve_binary_path()
+
+
+class MainTests(unittest.TestCase):
+    def test_main_invokes_embedded_binary_with_args(self) -> None:
+        completed = SimpleNamespace(returncode=0)
+
+        with (
+            mock.patch.object(launcher, "resolve_binary_path", return_value="/tmp/droppass"),
+            mock.patch.object(launcher.subprocess, "run", return_value=completed) as run_mock,
+        ):
+            exit_code = launcher.main(["version"])
+
+        run_mock.assert_called_once_with(["/tmp/droppass", "version"])
+        self.assertEqual(exit_code, 0)
+
+    def test_main_forwards_signal_exit(self) -> None:
+        completed = SimpleNamespace(returncode=-15)
+
+        with (
+            mock.patch.object(launcher, "resolve_binary_path", return_value="/tmp/droppass"),
+            mock.patch.object(launcher.subprocess, "run", return_value=completed),
+            mock.patch.object(launcher.os, "getpid", return_value=1234),
+            mock.patch.object(launcher.os, "kill") as kill_mock,
+        ):
+            exit_code = launcher.main(["version"])
+
+        kill_mock.assert_called_once_with(1234, 15)
+        self.assertEqual(exit_code, -15)