damon-devtools 0.1.0__tar.gz → 0.2.0__tar.gz

{damon_devtools-0.1.0 → damon_devtools-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: damon-devtools
-Version: 0.1.0
+Version: 0.2.0
 Summary: Developer CLI tools — portkill, removebg, apkpull
 Author: damon
 License: MIT

{damon_devtools-0.1.0 → damon_devtools-0.2.0}/damon_devtools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: damon-devtools
-Version: 0.1.0
+Version: 0.2.0
 Summary: Developer CLI tools — portkill, removebg, apkpull
 Author: damon
 License: MIT

damon_devtools-0.2.0/devtools/tools/apkpull/core.py

@@ -0,0 +1,303 @@
+import os
+import subprocess
+import re
+import tempfile
+import urllib.request
+import json
+
+# Local aapt2 binary directory
+AAPT2_LOCAL_DIR = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(__file__))),
+    "deps", "android-tools", "build"
+)
+
+# Remote aapt2 download base URL (android-11.0.0_r33)
+AAPT2_REMOTE_URL = "https://github.com/JonForShort/android-tools/raw/refs/heads/master/build/android-11.0.0_r33/aapt2/{arch}/bin/aapt2"
+
+# Device-side aapt2 path
+AAPT2_DEVICE_PATH = "/data/local/tmp/aapt2"
+
+# App name cache
+LABEL_CACHE_FILE = os.path.expanduser("~/.devtools/cache/apkpull/label_cache.json")
+
+def load_label_cache() -> dict[str, str]:
+    """Load cached app labels from file"""
+    if os.path.isfile(LABEL_CACHE_FILE):
+        try:
+            with open(LABEL_CACHE_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            return {}
+    return {}
+
+def save_label_cache(cache: dict[str, str]) -> None:
+    """Save app labels cache to file"""
+    try:
+        os.makedirs(os.path.dirname(LABEL_CACHE_FILE), exist_ok=True)
+        with open(LABEL_CACHE_FILE, "w", encoding="utf-8") as f:
+            json.dump(cache, f, ensure_ascii=False, indent=2)
+    except Exception:
+        pass
+
+# Global cache
+_label_cache: dict[str, str] | None = None
+
+def get_label_cache() -> dict[str, str]:
+    """Get or initialize the global label cache"""
+    global _label_cache
+    if _label_cache is None:
+        _label_cache = load_label_cache()
+    return _label_cache
+
+def check_adb() -> bool:
+    """检查 ADB 是否可用"""
+    try:
+        subprocess.run(["adb", "version"], capture_output=True, check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def get_device_serial() -> str | None:
+    """获取第一个已连接的设备序列号，多设备时返回第一个"""
+    try:
+        result = subprocess.run(["adb", "devices"], capture_output=True, text=True, encoding="utf-8", errors="replace", check=True)
+        lines = result.stdout.strip().split("\n")
+        for line in lines[1:]:
+            if line.strip() and not line.startswith("*"):
+                parts = line.split()
+                if len(parts) >= 2 and parts[1] == "device":
+                    return parts[0]
+        return None
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+def check_device() -> bool:
+    """检查设备是否连接"""
+    return get_device_serial() is not None
+
+def adb_cmd(args: list[str], serial: str | None = None) -> list[str]:
+    """构建带 -s 参数的 adb 命令"""
+    if serial:
+        return ["adb", "-s", serial] + args
+    return ["adb"] + args
+
+def check_aapt2_on_device() -> bool:
+    """Check if /data/local/tmp/aapt2 exists on device"""
+    serial = get_device_serial()
+    try:
+        result = subprocess.run(
+            adb_cmd(["shell", "test", "-f", AAPT2_DEVICE_PATH], serial),
+            capture_output=True, check=False
+        )
+        return result.returncode == 0
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def detect_device_arch() -> str | None:
+    """Get device CPU architecture via getprop"""
+    serial = get_device_serial()
+    try:
+        result = subprocess.run(
+            adb_cmd(["shell", "getprop", "ro.product.cpu.abi"], serial),
+            capture_output=True, text=True, encoding="utf-8", errors="replace", check=True
+        )
+        arch = result.stdout.strip()
+        return arch if arch else None
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+# Local aapt2 dir name -> device arch values
+ARCH_MAP = {
+    "arm64-v8a": ["arm64-v8a", "aarch64", "arm64"],
+    "armeabi-v7a": ["armeabi-v7a", "armeabi", "arm"],
+    "x86": ["x86", "i386", "i686"],
+    "x86_64": ["x86_64", "x64", "amd64"],
+}
+
+def find_local_aapt2(arch: str) -> str | None:
+    """Find local aapt2 binary matching device arch"""
+    if not os.path.isdir(AAPT2_LOCAL_DIR):
+        return None
+    for version in sorted(os.listdir(AAPT2_LOCAL_DIR), reverse=True):
+        version_path = os.path.join(AAPT2_LOCAL_DIR, version, "aapt2")
+        if not os.path.isdir(version_path):
+            continue
+        for arch_dir, aliases in ARCH_MAP.items():
+            if arch in aliases:
+                aapt2_path = os.path.join(version_path, arch_dir, "bin", "aapt2")
+                if os.path.isfile(aapt2_path):
+                    return aapt2_path
+    return None
+
+def download_aapt2(arch: str) -> str | None:
+    """Download aapt2 from GitHub and cache locally. Returns local path or None on failure."""
+    # Map device arch to download arch
+    arch_to_url_arch = {
+        "arm64-v8a": "arm64-v8a",
+        "aarch64": "arm64-v8a",
+        "arm64": "arm64-v8a",
+        "armeabi-v7a": "armeabi-v7a",
+        "armeabi": "armeabi-v7a",
+        "arm": "armeabi-v7a",
+        "x86": "x86",
+        "i386": "x86",
+        "i686": "x86",
+        "x86_64": "x86_64",
+        "x64": "x86_64",
+        "amd64": "x86_64",
+    }
+    url_arch = arch_to_url_arch.get(arch, arch)
+    url = AAPT2_REMOTE_URL.format(arch=url_arch)
+
+    # Cache path: AAPT2_LOCAL_DIR/android-11.0.0_r33/aapt2/{arch}/bin/aapt2
+    cache_dir = os.path.join(AAPT2_LOCAL_DIR, "android-11.0.0_r33", "aapt2", url_arch, "bin")
+    cache_path = os.path.join(cache_dir, "aapt2")
+
+    if os.path.isfile(cache_path):
+        return cache_path
+
+    try:
+        os.makedirs(cache_dir, exist_ok=True)
+        print(f"正在下载 aapt2 ({arch})...")
+        urllib.request.urlretrieve(url, cache_path)
+        # Make executable
+        os.chmod(cache_path, 0o755)
+        return cache_path
+    except Exception as e:
+        print(f"下载失败: {e}")
+        return None
+
+def ensure_aapt2_on_device() -> bool:
+    """Push local aapt2 to device if missing; return success"""
+    if check_aapt2_on_device():
+        return True
+
+    serial = get_device_serial()
+    arch = detect_device_arch()
+    if not arch:
+        print("警告: 无法获取设备架构，使用 arm64-v8a")
+        arch = "arm64-v8a"
+
+    local_aapt2 = find_local_aapt2(arch)
+    if not local_aapt2:
+        print(f"本地未找到 aapt2 ({arch})，尝试下载...")
+        local_aapt2 = download_aapt2(arch)
+        if not local_aapt2:
+            print(f"警告: 下载失败，回退到 pm dump 方式")
+            return False
+
+    try:
+        print(f"正在推送 aapt2 ({arch}) 到设备...")
+        subprocess.run(
+            adb_cmd(["push", local_aapt2, AAPT2_DEVICE_PATH], serial),
+            capture_output=True, text=True, encoding="utf-8", errors="replace", check=True
+        )
+        subprocess.run(
+            adb_cmd(["shell", "chmod", "0755", AAPT2_DEVICE_PATH], serial),
+            capture_output=True, check=True
+        )
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def scan_packages() -> list[str]:
+    """执行 adb shell pm list packages -3，返回包名列表"""
+    serial = get_device_serial()
+    result = subprocess.run(
+        adb_cmd(["shell", "pm", "list", "packages", "-3"], serial),
+        capture_output=True, text=True, encoding="utf-8", errors="replace", check=True
+    )
+    pkgs = []
+    for line in result.stdout.strip().split("\n"):
+        line = line.strip()
+        if line.startswith("package:"):
+            pkgs.append(line[8:])
+    return pkgs
+
+def get_apk_path(pkg: str) -> str | None:
+    """执行 pm path，返回 APK 物理路径"""
+    serial = get_device_serial()
+    try:
+        result = subprocess.run(
+            adb_cmd(["shell", "pm", "path", pkg], serial),
+            capture_output=True, text=True, encoding="utf-8", errors="replace", check=True
+        )
+        for line in result.stdout.strip().split("\n"):
+            if line.startswith("package:"):
+                return line[8:].strip()
+        return None
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+def get_app_name_pm_dump(pkg: str) -> str:
+    """通过设备端 pm dump 提取 application label（失败时回退包名）"""
+    serial = get_device_serial()
+    try:
+        result = subprocess.run(
+            adb_cmd(["shell", "pm", "dump", pkg], serial),
+            capture_output=True, text=True, encoding="utf-8", errors="replace"
+        )
+        if result.returncode != 0:
+            return pkg
+        for line in result.stdout.splitlines():
+            # application-label:'Facebook'
+            # application-label-zh-CN:'微信'
+            m = re.search(r"application-label(?:-[^:]+)?:'(.+?)'", line)
+            if m:
+                return m.group(1)
+        return pkg
+    except Exception:
+        return pkg
+
+def get_app_name_aapt2(pkg: str) -> str | None:
+    """Use device-side aapt2 dump badging to get app label. Returns None on failure."""
+    apk_path = get_apk_path(pkg)
+    if not apk_path:
+        return None
+    serial = get_device_serial()
+    try:
+        cmd = f'/data/local/tmp/aapt2 dump badging "{apk_path}"'
+        result = subprocess.run(
+            adb_cmd(["shell", cmd], serial),
+            capture_output=True, text=True, encoding="utf-8", errors="replace"
+        )
+        if result.returncode != 0:
+            return None
+        for line in result.stdout.splitlines():
+            m = re.search(r"^application-label:'(.+?)'", line)
+            if m:
+                return m.group(1)
+        return None
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+def get_app_name(pkg: str) -> str:
+    """Get app label: check cache first, then fetch and cache"""
+    cache = get_label_cache()
+    if pkg in cache:
+        return cache[pkg]
+
+    label = get_app_name_aapt2(pkg)
+    if not label:
+        label = get_app_name_pm_dump(pkg)
+
+    cache[pkg] = label
+    save_label_cache(cache)
+    return label
+
+def sanitize_filename(name: str) -> str:
+    """Sanitize filename for cross-platform compatibility."""
+    sanitized = re.sub(r'[\\/:*?"<>|]+', "_", name).strip().rstrip(".")
+    return sanitized or "unknown"
+
+def pull_apk(apk_path: str, dest_path: str) -> bool:
+    """执行 adb pull，拉取 APK 到目标文件路径"""
+    serial = get_device_serial()
+    try:
+        subprocess.run(
+            adb_cmd(["pull", apk_path, dest_path], serial),
+            capture_output=True, text=True, encoding="utf-8", errors="replace", check=True
+        )
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False

{damon_devtools-0.1.0 → damon_devtools-0.2.0}/devtools/tools/apkpull/ui.py

@@ -3,12 +3,13 @@ if sys.platform == "win32":
     sys.stdout.reconfigure(encoding="utf-8")
 
 import os
+import argparse
 import threading
 from devtools.tools.apkpull.models import PackageInfo
 
 def scan_packages_with_labels() -> list[PackageInfo]:
     """Scan packages and fetch labels in parallel threads (max 10 concurrent)"""
-    from devtools.tools.apkpull.core import scan_packages, check_adb, check_device, get_app_name
+    from devtools.tools.apkpull.core import scan_packages, check_adb, check_device, get_app_name, ensure_aapt2_on_device
 
     if not check_adb():
         print("错误: 未找到 adb 命令，请确保 Android SDK platform-tools 已安装并加入 PATH")
@@ -17,6 +18,7 @@ def scan_packages_with_labels() -> list[PackageInfo]:
         print("错误: 未检测到设备，请确保手机已通过 USB 连接并开启了 USB 调试模式")
         return []
 
+    ensure_aapt2_on_device()
     print("正在获取应用列表...")
     pkgs = scan_packages()
     if not pkgs:
@@ -53,12 +55,12 @@ def scan_packages_with_labels() -> list[PackageInfo]:
 
 def show_packages(packages: list[PackageInfo], short: bool = True) -> None:
     print()
-    print(f"{'#':<5} {'应用名':<30} {'包名'}")
+    print(f"{'#':<5} {'包名':<50} {'应用名'}")
     print("-" * 90)
     for i, p in enumerate(packages):
-        label = p.label[:28] + ".." if short and len(p.label) > 30 else p.label
-        pkg = p.pkg[:50] if short and len(p.pkg) > 50 else p.pkg
-        print(f"{i+1:<5} {label:<30} {pkg}")
+        pkg = p.pkg[:48] + ".." if short and len(p.pkg) > 50 else p.pkg
+        label = p.label[:38] + ".." if short and len(p.label) > 40 else p.label
+        print(f"{i+1:<5} {pkg:<50} {label}")
 
 def select_packages(packages: list[PackageInfo], user_input: str) -> list[PackageInfo]:
     """Parse user input: keyword search or numeric selection (1,3-5, 1,3,5)"""
@@ -108,17 +110,26 @@ def run(args: list[str] | None = None):
     if args is None:
         args = []
 
-    # Determine destination directory
-    if args:
-        dest_dir = args[0]
-    else:
-        dest_dir = os.getcwd()
+    parser = argparse.ArgumentParser(prog="apkpull", description="Pull APK from Android device")
+    parser.add_argument("dest_dir", nargs="?", default=os.getcwd(), help="目标目录 (默认当前目录)")
+    parser.add_argument("-s", "--search", metavar="KEYWORD", help="模糊搜索应用名/包名并退出")
+
+    parsed = parser.parse_args(args)
 
     packages = scan_packages_with_labels()
     if not packages:
         return
 
-    show_packages(packages)
+    # Fuzzy search mode: pre-filter packages and enter selection loop
+    if parsed.search:
+        keyword = parsed.search.lower()
+        packages = [p for p in packages if keyword in p.label.lower() or keyword in p.pkg.lower()]
+        if not packages:
+            print(f"未找到包含 '{parsed.search}' 的应用")
+            return
+        show_packages(packages)
+    else:
+        show_packages(packages)
 
     while True:
         print()
@@ -142,12 +153,12 @@ def run(args: list[str] | None = None):
 
         show_packages(selected, short=False)
 
-        if not confirm_pull(selected, dest_dir):
+        if not confirm_pull(selected, parsed.dest_dir):
             print("取消拉取")
             continue
 
         # Pull APKs
-        from devtools.tools.apkpull.core import get_apk_path, pull_apk
+        from devtools.tools.apkpull.core import get_apk_path, pull_apk, sanitize_filename
         succeeded: list[str] = []
         failed: list[tuple] = []
 
@@ -156,7 +167,9 @@ def run(args: list[str] | None = None):
             if not apk_path:
                 failed.append((p.label, "未找到 APK 路径"))
                 continue
-            if pull_apk(apk_path, dest_dir):
+            file_base = p.label if p.label and p.label != p.pkg else p.pkg
+            dest_apk = os.path.join(parsed.dest_dir, f"{sanitize_filename(file_base)}.apk")
+            if pull_apk(apk_path, dest_apk):
                 succeeded.append(p.label)
             else:
                 failed.append((p.label, "拉取失败"))

{damon_devtools-0.1.0 → damon_devtools-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "damon-devtools"
-version = "0.1.0"
+version = "0.2.0"
 description = "Developer CLI tools — portkill, removebg, apkpull"
 readme = "README.md"
 requires-python = ">=3.10"

damon_devtools-0.1.0/devtools/tools/apkpull/core.py

@@ -1,123 +0,0 @@
-import subprocess
-import re
-import os
-import tempfile
-
-def _find_aapt() -> str | None:
-    """Find aapt.exe — checks PATH first, then Android SDK build-tools"""
-    # 1. Check PATH
-    import shutil as _shutil
-    path_aapt = _shutil.which("aapt")
-    if path_aapt and os.path.isfile(path_aapt):
-        return path_aapt
-    path_aapt2 = _shutil.which("aapt2")
-    if path_aapt2 and os.path.isfile(path_aapt2):
-        return path_aapt2
-    # 2. Check Android SDK build-tools
-    sdk_base = os.environ.get("LOCALAPPDATA", "") + "/Android/Sdk"
-    build_tools = os.path.join(sdk_base, "build-tools")
-    if os.path.isdir(build_tools):
-        versions = sorted(os.listdir(build_tools), reverse=True)
-        for v in versions:
-            for binary in ("aapt.exe", "aapt2.exe"):
-                aapt = os.path.join(build_tools, v, binary)
-                if os.path.isfile(aapt):
-                    return aapt
-    return None
-
-AAPT_PATH = _find_aapt()
-
-def check_adb() -> bool:
-    """检查 ADB 是否可用"""
-    try:
-        subprocess.run(["adb", "version"], capture_output=True, check=True)
-        return True
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        return False
-
-def check_device() -> bool:
-    """检查设备是否连接"""
-    try:
-        result = subprocess.run(["adb", "devices"], capture_output=True, text=True, encoding="utf-8", errors="replace", check=True)
-        lines = result.stdout.strip().split("\n")
-        for line in lines[1:]:
-            if line.strip() and not line.startswith("*"):
-                parts = line.split()
-                if len(parts) >= 2 and parts[1] == "device":
-                    return True
-        return False
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        return False
-
-def scan_packages() -> list[str]:
-    """执行 adb shell pm list packages -3，返回包名列表"""
-    result = subprocess.run(
-        ["adb", "shell", "pm", "list", "packages", "-3"],
-        capture_output=True, text=True, encoding="utf-8", errors="replace", check=True
-    )
-    pkgs = []
-    for line in result.stdout.strip().split("\n"):
-        line = line.strip()
-        if line.startswith("package:"):
-            pkgs.append(line[8:])
-    return pkgs
-
-def get_apk_path(pkg: str) -> str | None:
-    """执行 pm path，返回 APK 物理路径"""
-    try:
-        result = subprocess.run(
-            ["adb", "shell", "pm", "path", pkg],
-            capture_output=True, text=True, encoding="utf-8", errors="replace", check=True
-        )
-        for line in result.stdout.strip().split("\n"):
-            if line.startswith("package:"):
-                return line[8:].strip()
-        return None
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        return None
-
-def get_app_name(pkg: str) -> str:
-    """通过 aapt 提取 APK 的 application label"""
-    if not AAPT_PATH:
-        return pkg
-    apk_path = get_apk_path(pkg)
-    if not apk_path:
-        return pkg
-    tmp = os.path.join(tempfile.gettempdir(), f"apkpull_{os.getpid()}_{pkg.replace('.', '_')}.apk")
-    try:
-        # pull APK to temp file
-        pull_ok = subprocess.run(
-            ["adb", "pull", apk_path, tmp],
-            capture_output=True, encoding="utf-8", errors="replace"
-        ).returncode == 0
-        if not pull_ok or not os.path.exists(tmp):
-            return pkg
-        # extract label via aapt
-        result = subprocess.run(
-            [AAPT_PATH, "dump", "badging", tmp],
-            capture_output=True, encoding="utf-8", errors="replace"
-        )
-        for line in result.stdout.split("\n"):
-            m = re.search(r"application-label:'(.+?)'", line)
-            if m:
-                return m.group(1)
-        return pkg
-    except Exception:
-        return pkg
-    finally:
-        if os.path.exists(tmp):
-            try:
-                os.remove(tmp)
-            except OSError:
-                pass
-
-def pull_apk(apk_path: str, dest_dir: str) -> bool:
-    """执行 adb pull，拉取 APK 到目标目录"""
-    try:
-        subprocess.run(
-            ["adb", "pull", apk_path, dest_dir],
-            capture_output=True, text=True, encoding="utf-8", errors="replace", check=True
-        )
-        return True
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        return False