apkdev 2.0.0__py3-none-any.whl

apkdev/cli.py

@@ -0,0 +1,925 @@
+"""CLI entry point — click-based command interface."""
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from . import __version__
+from .builder import create_project, build_apk, sign_apk
+from .device import devices, install_apk, uninstall, pull_apk, list_packages
+from .inspector import inspect, manifest, permissions, strings, resources, analyze
+from .optimizer import optimize
+from .apkfile import list_contents, extract_apk, certificate
+from .reverser import (
+    apktool_decode,
+    apktool_rebuild,
+    jadx_decompile,
+    smali_assemble,
+    baksmali_disassemble,
+    dex2jar,
+    apkeditor,
+)
+from .sdk import info, setup, detect_platform
+from .utils import banner
+
+console = Console()
+CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"])
+
+
+class AliasedGroup(click.Group):
+    """Allow abbreviated commands (e.g. 'b' for 'build')."""
+
+    def get_command(self, ctx, cmd_name):
+        rv = click.Group.get_command(self, ctx, cmd_name)
+        if rv is not None:
+            return rv
+        matches = [x for x in self.list_commands(ctx) if x.startswith(cmd_name)]
+        if len(matches) == 1:
+            return click.Group.get_command(self, ctx, matches[0])
+        if len(matches) > 1:
+            ctx.fail(f"'{cmd_name}' is ambiguous: {', '.join(matches)}")
+        ctx.fail(f"No such command '{cmd_name}'.")
+        return None
+
+
+def _version_cb(ctx, param, value):
+    if not value or ctx.resilient_parsing:
+        return
+    click.echo(f"apkdev, version {__version__}")
+    ctx.exit()
+
+
+@click.group(cls=AliasedGroup, context_settings=CONTEXT_SETTINGS)
+@click.option("--version", is_flag=True, callback=_version_cb, expose_value=False, help="Show version")
+def cli():
+    """📱 APKDev — The complete Android APK toolkit.
+    
+    Build APKs from scratch, reverse engineer any APK, extract metadata,
+    manage devices, and more — all from one command.
+    
+    Examples:
+      apkdev new MyApp          Create new project
+      apkdev build              Build APK
+      apkdev decode app.apk     Decompile with apktool
+      apkdev decompile app.apk  Decompile to Java with jadx
+      apkdev inspect app.apk    Show full APK metadata
+      apkdev install app.apk    Install to device
+    """
+    pass
+
+
+# ═══════════════════════════════════════════════════════════════
+#  BUILD COMMANDS
+# ═══════════════════════════════════════════════════════════════
+
+@cli.command("new", help="Create a new Kotlin APK project")
+@click.argument("name", default="MyApp")
+def new(name):
+    """Scaffold a new Android project with Kotlin + Gradle."""
+    console.print(banner())
+    proj = create_project(name)
+    console.print(f"\n[green]✅ Project created:[/] {proj}")
+    console.print(f"   [dim]cd {name} && apkdev build[/]")
+
+
+@cli.command("build", help="Build APK (gradle assembleDebug)")
+@click.argument("directory", required=False, default=None)
+def build(directory):
+    """Compile APK via Gradle."""
+    build_apk(directory)
+
+
+@cli.command("sign", help="Sign an APK with debug keystore")
+@click.argument("apk_path")
+def sign(apk_path):
+    """Sign an unsigned APK with the auto-generated debug key."""
+    sign_apk(apk_path)
+
+
+@cli.command("optimize", help="Zipalign + sign APK")
+@click.argument("apk_path")
+def _optimize(apk_path):
+    """Optimize APK: zipalign (4-byte alignment) then sign."""
+    optimize(apk_path)
+
+
+# ═══════════════════════════════════════════════════════════════
+#  DEVICE COMMANDS (ADB)
+# ═══════════════════════════════════════════════════════════════
+
+@cli.command("devices", help="List connected Android devices")
+def _devices():
+    """Show connected ADB devices."""
+    devices()
+
+
+@cli.command("install", help="Install APK to device via ADB")
+@click.argument("apk_path")
+@click.option("-s", "--serial", help="Device serial number")
+def _install(apk_path, serial):
+    """Install an APK to a connected device (adb install -r -t)."""
+    install_apk(apk_path, serial)
+
+
+@cli.command("uninstall", help="Remove app from device via ADB")
+@click.argument("package")
+@click.option("-s", "--serial", help="Device serial number")
+def _uninstall(package, serial):
+    """Uninstall a package from a connected device."""
+    uninstall(package, serial)
+
+
+@cli.command("pull", help="Pull APK from device by package name")
+@click.argument("package")
+@click.argument("output", required=False, default=None)
+@click.option("-s", "--serial", help="Device serial number")
+def _pull(package, output, serial):
+    """Pull an installed app's APK from a connected device."""
+    pull_apk(package, output, serial)
+
+
+@cli.command("packages", help="List installed packages on device")
+@click.argument("filter", required=False, default=None)
+@click.option("-s", "--serial", help="Device serial number")
+def _packages(filter, serial):
+    """List installed packages on a connected device."""
+    list_packages(serial, filter)
+
+
+# ═══════════════════════════════════════════════════════════════
+#  REVERSE ENGINEERING COMMANDS
+# ═══════════════════════════════════════════════════════════════
+
+@cli.command("decode", help="Decode APK with apktool")
+@click.argument("apk_file")
+@click.argument("output", required=False, default=None)
+def decode(apk_file, output):
+    """Decompile an APK to smali/resources with Apktool."""
+    apktool_decode(apk_file, output)
+
+
+@cli.command("rebuild", help="Rebuild APK from decoded directory")
+@click.argument("directory")
+@click.argument("output", required=False, default=None)
+def rebuild(directory, output):
+    """Rebuild an APK from an apktool-decoded directory."""
+    apktool_rebuild(directory, output)
+
+
+@cli.command("decompile", help="Decompile DEX/APK to Java with jadx")
+@click.argument("target")
+@click.argument("output", required=False, default=None)
+@click.option("--show-bad-code", is_flag=True, help="Show code even with errors")
+def decompile(target, output, show_bad_code):
+    """Decompile DEX or APK to readable Java source using jadx."""
+    jadx_decompile(target, output)
+
+
+@cli.command("smali", help="Assemble smali → dex")
+@click.argument("smali_dir")
+@click.argument("output", required=False, default=None)
+def smali(smali_dir, output):
+    """Assemble smali source files into a DEX file."""
+    smali_assemble(smali_dir, output)
+
+
+@cli.command("baksmali", help="Disassemble dex → smali")
+@click.argument("dex_file")
+@click.argument("output", required=False, default=None)
+def baksmali(dex_file, output):
+    """Disassemble a DEX file into human-readable smali."""
+    baksmali_disassemble(dex_file, output)
+
+
+@cli.command("jar", help="Convert DEX/APK to JAR")
+@click.argument("dex_file")
+@click.argument("output", required=False, default=None)
+def jar(dex_file, output):
+    """Convert DEX or APK to a JAR file using dex2jar."""
+    dex2jar(dex_file, output)
+
+
+@cli.command("apkeditor", help="Run APKEditor (merge/split/modify APK)")
+@click.argument("args", nargs=-1, required=True)
+def apkeditor_cmd(args):
+    """Pass arguments directly to APKEditor."""
+    apkeditor(*args)
+
+
+# ═══════════════════════════════════════════════════════════════
+#  APK INSPECTION COMMANDS
+# ═══════════════════════════════════════════════════════════════
+
+@cli.command("inspect", help="Show all APK metadata")
+@click.argument("apk_path")
+def _inspect(apk_path):
+    """Full APK analysis: package, version, permissions, activities, services, etc."""
+    inspect(apk_path)
+
+
+@cli.command("manifest", help="Extract AndroidManifest.xml")
+@click.argument("apk_path")
+def _manifest(apk_path):
+    """Dump the full AndroidManifest.xml in readable format."""
+    manifest(apk_path)
+
+
+@cli.command("permissions", help="List APK permissions")
+@click.argument("apk_path")
+def _permissions(apk_path):
+    """List all permissions requested by the APK."""
+    permissions(apk_path)
+
+
+@cli.command("strings", help="Extract resource strings from APK")
+@click.argument("apk_path")
+def _strings(apk_path):
+    """Dump the resource string pool from the APK."""
+    strings(apk_path)
+
+
+@cli.command("resources", help="List APK resource table")
+@click.argument("apk_path")
+def _resources(apk_path):
+    """Dump the full resource table from the APK."""
+    resources(apk_path)
+
+
+@cli.command("analyze", help="Deep analysis with androguard")
+@click.argument("apk_path")
+def _analyze(apk_path):
+    """Deep static analysis using androguard (permissions, components, etc.)."""
+    analyze(apk_path)
+
+
+# ═══════════════════════════════════════════════════════════════
+#  FILE COMMANDS
+# ═══════════════════════════════════════════════════════════════
+
+@cli.command("ls", help="List APK contents (files inside)")
+@click.argument("apk_path")
+def _ls(apk_path):
+    """List all files inside an APK archive."""
+    list_contents(apk_path)
+
+
+@cli.command("extract", help="Extract APK contents to directory")
+@click.argument("apk_path")
+@click.argument("output", required=False, default=None)
+def _extract(apk_path, output):
+    """Extract all files from an APK (like unzip)."""
+    extract_apk(apk_path, output)
+
+
+@cli.command("cert", help="Show APK signing certificate info")
+@click.argument("apk_path")
+def _cert(apk_path):
+    """Display signing certificate information for an APK."""
+    certificate(apk_path)
+
+
+# ═══════════════════════════════════════════════════════════════
+#  NATIVE BINARY RE COMMANDS (for .so / ELF / PE binaries)
+# ═══════════════════════════════════════════════════════════════
+
+@cli.command("elf", help="Analyze ELF binary (headers, sections, symbols)")
+@click.argument("binary", required=True)
+def _elf(binary):
+    """Analyze an ELF binary (.so shared library or executable)."""
+    import subprocess
+    from pathlib import Path
+    
+    path = Path(binary)
+    if not path.exists():
+        console.print(f"[red]❌ File not found: {binary}[/]")
+        return
+    
+    console.print(f"[bold cyan]📄 ELF Analysis: {path.name}[/]")
+    console.print()
+    
+    # File info
+    r = subprocess.run(["file", str(path)], capture_output=True, text=True, timeout=5)
+    console.print(f"[bold]File:[/] {r.stdout.strip()}")
+    console.print()
+    
+    # ELF header
+    console.print("[bold]ELF Header:[/]")
+    r = subprocess.run(["readelf", "-h", str(path)], capture_output=True, text=True, timeout=5)
+    console.print(r.stdout)
+    
+    # Sections
+    console.print("[bold]Sections:[/]")
+    r = subprocess.run(["readelf", "-S", str(path)], capture_output=True, text=True, timeout=5)
+    for line in r.stdout.split(chr(10)):
+        if "Name" in line or ".text" in line or ".data" in line or ".rodata" in line or ".bss" in line or "PROGBITS" in line or "NOBITS" in line:
+            console.print(f"  {line}")
+    console.print()
+    
+    # Dynamic symbols (functions)
+    console.print("[bold]Exported Functions (dynamic symbols):[/]")
+    r = subprocess.run(["readelf", "--dyn-syms", "--wide", str(path)], capture_output=True, text=True, timeout=5)
+    lines = [l for l in r.stdout.split(chr(10)) if " FUNC " in l]
+    for line in lines[:30]:
+        console.print(f"  {line}")
+    if len(lines) > 30:
+        console.print(f"  ... and {len(lines)-30} more")
+
+
+@cli.command("disasm", help="Disassemble native binary with Capstone (ARM64/ARM/x86)")
+@click.argument("binary", required=True)
+@click.option("--arch", default="auto", help="Architecture: auto, arm64, arm, x86_64, x86")
+@click.option("--count", default=60, help="Lines of disassembly to show")
+@click.option("--func", "-f", default=None, help="Function address (hex) to focus on")
+def _disasm(binary, arch, count, func):
+    """Disassemble a native binary (.so / ELF) using Capstone engine.
+    Shows ARM64/ARM/x86 disassembly with function boundaries highlighted.
+    """
+    import struct, subprocess
+    from pathlib import Path
+    
+    path = Path(binary)
+    if not path.exists():
+        console.print(f"[red]File not found: {binary}[/]")
+        return
+    
+    try:
+        from capstone import Cs, CS_ARCH_ARM64, CS_MODE_ARM, CS_ARCH_ARM, CS_ARCH_X86, CS_MODE_64, CS_MODE_32
+    except ImportError:
+        console.print("[yellow]Capstone not installed, falling back to objdump...[/]")
+        r = subprocess.run(["objdump", "-d", str(path)], capture_output=True, text=True, timeout=30)
+        for line in r.stdout.split(chr(10))[:count]:
+            console.print(line)
+        return
+    
+    data = path.read_bytes()
+    if data[:4] != b'\x7fELF':
+        console.print("[red]Not an ELF file[/]")
+        return
+    
+    # Parse ELF section headers
+    e_shoff = struct.unpack_from('<Q', data, 40)[0]
+    e_shentsize = struct.unpack_from('<H', data, 58)[0]
+    e_shnum = struct.unpack_from('<H', data, 60)[0]
+    e_shstrndx = struct.unpack_from('<H', data, 62)[0]
+    strtab_off = struct.unpack_from('<Q', data[e_shoff + e_shstrndx * e_shentsize + 24:], 0)[0]
+    
+    text_addr = text_off = text_sz = None
+    for i in range(e_shnum):
+        shdr = data[e_shoff + i * e_shentsize:]
+        name_off = struct.unpack_from('<I', shdr, 0)[0]
+        sh_addr = struct.unpack_from('<Q', shdr, 16)[0]
+        sh_off = struct.unpack_from('<Q', shdr, 24)[0]
+        sh_sz = struct.unpack_from('<Q', shdr, 32)[0]
+        name = data[strtab_off + name_off:].split(b'\x00')[0].decode(errors='replace')
+        if name == '.text':
+            text_addr, text_off, text_sz = sh_addr, sh_off, sh_sz
+            break
+    
+    if text_addr is None:
+        console.print("[red]Could not find .text section[/]")
+        return
+    
+    # Set up Capstone architecture
+    if arch == "auto":
+        fi = subprocess.run(["file", str(path)], capture_output=True, text=True, timeout=5).stdout
+        if "aarch64" in fi:
+            cs_arch, cs_mode = CS_ARCH_ARM64, CS_MODE_ARM
+        elif "ARM" in fi:
+            cs_arch, cs_mode = CS_ARCH_ARM, CS_MODE_ARM
+        elif "x86-64" in fi:
+            cs_arch, cs_mode = CS_ARCH_X86, CS_MODE_64
+        else:
+            cs_arch, cs_mode = CS_ARCH_ARM64, CS_MODE_ARM
+    elif arch in ("arm64", "aarch64"):
+        cs_arch, cs_mode = CS_ARCH_ARM64, CS_MODE_ARM
+    elif arch == "arm":
+        cs_arch, cs_mode = CS_ARCH_ARM, CS_MODE_ARM
+    elif arch == "x86_64":
+        cs_arch, cs_mode = CS_ARCH_X86, CS_MODE_64
+    elif arch == "x86":
+        cs_arch, cs_mode = CS_ARCH_X86, CS_MODE_32
+    else:
+        cs_arch, cs_mode = CS_ARCH_ARM64, CS_MODE_ARM
+    
+    md = Cs(cs_arch, cs_mode)
+    arch_name = {CS_ARCH_ARM64: "ARM64", CS_ARCH_ARM: "ARM", CS_ARCH_X86: "x86_64"}.get(cs_arch, "?")
+    
+    if func is not None:
+        func_addr = int(func, 16) if func.startswith('0x') else int(func)
+        code_off = func_addr - text_addr + text_off
+        code = data[code_off:code_off + 0x200]
+        base = func_addr
+        console.print(f"[bold cyan]Function at 0x{func_addr:x} ({arch_name})[/]")
+    else:
+        code = data[text_off:text_off + min(text_sz, 0x200)]
+        base = text_addr
+        console.print(f"[bold cyan]Disassembly: {path.name} ({arch_name})[/]")
+    console.print()
+    
+    insns = list(md.disasm(code, base))
+    
+    # Find function boundaries by scanning for BL instruction bytes
+    bl_targets = set()
+    for i, byte in enumerate(code):
+        if byte == 0x94 and i + 4 <= len(code):  # BL in ARM64
+            # Extract the target from the BL instruction
+            bl_insn = int.from_bytes(code[i:i+4], 'little')
+            offset = (bl_insn & 0x3FFFFFF) << 2
+            if bl_insn & 0x2000000:  # Sign extend
+                offset = offset - 0x100000000
+            target = base + i + offset
+            bl_targets.add(target)
+    
+    displayed = 0
+    for insn in insns:
+        if displayed >= count:
+            console.print(f"... ({len(insns)-displayed} more — use --count to show more)")
+            break
+        if insn.address in bl_targets and insn.address != base:
+            console.print(f"[bold cyan]--- Function at 0x{insn.address:x} ---[/]")
+        if insn.mnemonic in ('bl', 'blr'):
+            console.print(f"  [yellow]0x{insn.address:x}:  {insn.mnemonic:10s} {insn.op_str}[/]")
+        elif insn.mnemonic in ('ret',):
+            console.print(f"  [green]0x{insn.address:x}:  {insn.mnemonic:10s} {insn.op_str}[/]")
+        elif insn.mnemonic.startswith('b.'):
+            console.print(f"  [magenta]0x{insn.address:x}:  {insn.mnemonic:10s} {insn.op_str}[/]")
+        elif insn.mnemonic in ('b', 'cbz', 'cbnz', 'tbz', 'tbnz'):
+            console.print(f"  [magenta]0x{insn.address:x}:  {insn.mnemonic:10s} {insn.op_str}[/]")
+        else:
+            console.print(f"  0x{insn.address:x}:  {insn.mnemonic:10s} {insn.op_str}")
+        displayed += 1
+    
+    if not insns:
+        console.print("[red]No instructions disassembled. Try --arch arm or x86_64[/]")
+
+
+@cli.command("strings", help="Extract strings from any binary")
+@click.argument("binary", required=True)
+@click.option("--min", default=6, help="Minimum string length")
+@click.option("--max", default=100, help="Maximum strings to show")
+def _nstrings(binary, min, max):
+    """Extract readable strings from a binary (.so, APK, DEX, etc.).
+    Pure Python implementation — no external tools needed."""
+    from pathlib import Path
+    
+    path = Path(binary)
+    if not path.exists():
+        console.print(f"[red]❌ File not found: {binary}[/]")
+        return
+    
+    data = path.read_bytes()
+    strings_found = []
+    current = []
+    
+    for byte in data:
+        if 32 <= byte <= 126:
+            current.append(chr(byte))
+        else:
+            if len(current) >= min:
+                strings_found.append("".join(current))
+            current = []
+    if len(current) >= min:
+        strings_found.append("".join(current))
+    
+    console.print(f"[bold cyan]📝 Strings in {path.name}[/] ({len(strings_found)} found)")
+    console.print()
+    for s in strings_found[:max]:
+        console.print(f"  {s}")
+    if len(strings_found) > max:
+        console.print(f"  ... and {len(strings_found)-max} more")
+
+
+@cli.command("debug", help="Debug a native process with GDB")
+@click.argument("target", required=True)
+@click.option("--args", default="", help="Arguments for the target")
+def _debug(target, args):
+    """Start GDB for debugging a native binary or attach to a PID."""
+    import subprocess, os, signal
+    
+    gdb = shutil.which("gdb")
+    if not gdb:
+        console.print("[red]❌ GDB not found. Install: pkg install gdb[/]")
+        return
+    
+    console.print(f"[bold cyan]🐛 GDB Debug: {target}[/]")
+    console.print("[yellow]Starting GDB... (type 'quit' to exit)[/]")
+    console.print()
+    
+    try:
+        if target.isdigit():
+            # Attach to PID
+            subprocess.run([gdb, "-p", target])
+        else:
+            # Run binary
+            cmd = [gdb, "--args", target] + args.split()
+            subprocess.run(cmd)
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        console.print(f"[red]❌ GDB failed: {e}[/]")
+
+
+
+@cli.command("patch", help="Patch bytes in a native binary (.so / ELF)")
+@click.argument("binary")
+@click.option("--offset", "-o", default=None, help="Hex offset to patch (e.g. 0x1234)")
+@click.option("--bytes", "-b", default=None, help="Bytes to write (hex, e.g. 1F2003D5)")
+@click.option("--string", "-s", default=None, help="String to write")
+@click.option("--nop", "-n", default=None, type=int, help="NOP out N instructions at offset")
+@click.option("--find", "-f", default=None, help="Find string/hex in binary")
+@click.option("--replace", "-r", default=None, help="Replace string in binary")
+@click.option("--hexdump", "-x", default=None, type=int, help="Show hex dump N lines at offset")
+def _patch(binary, offset, bytes, string, nop, find, replace, hexdump):
+    """Patch a native binary (.so, ELF, or any file).
+    
+    Examples:
+      apkdev patch lib.so --offset 0x1234 --bytes 1F2003D5
+      apkdev patch lib.so --offset 0x5678 --nop 4
+      apkdev patch lib.so --string "old" --replace "new"
+      apkdev patch lib.so --find "check" --replace "allow"
+      apkdev patch lib.so --hexdump 20
+    """
+    from pathlib import Path
+    
+    path = Path(binary)
+    if not path.exists():
+        console.print(f"[red]❌ File not found: {binary}[/]")
+        return
+    
+    data = bytearray(path.read_bytes())
+    
+    # Parse offset
+    off = None
+    if offset is not None:
+        off = int(offset, 16) if offset.startswith("0x") else int(offset)
+    
+    # Hex dump
+    if hexdump is not None and off is not None:
+        console.print(f"[bold cyan]📋 Hex dump at 0x{off:x}:[/]")
+        start = max(0, off - 8)
+        for i in range(hexdump):
+            addr = start + i * 16
+            if addr >= len(data):
+                break
+            hex_part = " ".join(f"{data[j]:02x}" for j in range(addr, min(addr+16, len(data))))
+            ascii_part = "".join(chr(data[j]) if 32 <= data[j] <= 126 else "." for j in range(addr, min(addr+16, len(data))))
+            marker = " →" if addr <= off < addr+16 else "  "
+            console.print(f"  {marker} 0x{addr:08x}: {hex_part:<48} {ascii_part}")
+        return
+    
+    # Find and replace
+    if find is not None:
+        if replace is not None:
+            # String replace
+            # Auto-detect: if input is pure hex (no spaces, even length), treat as hex
+            pure_hex = all(c in '0123456789abcdefABCDEF' for c in find) and len(find) % 2 == 0
+            find_bytes = bytes.fromhex(find) if pure_hex else find.encode()
+            pure_hex_r = all(c in '0123456789abcdefABCDEF' for c in replace) and len(replace) % 2 == 0
+            replace_bytes = bytes.fromhex(replace) if pure_hex_r else replace.encode()
+            count = 0
+            idx = data.find(find_bytes)
+            while idx >= 0:
+                for j, b in enumerate(replace_bytes):
+                    data[idx + j] = b
+                count += 1
+                idx = data.find(find_bytes, idx + len(replace_bytes))
+            console.print(f"[green]✅ Replaced {count} occurrence(s) of '{find}' → '{replace}'[/]")
+            path.write_bytes(data)
+            return
+        else:
+            # Find only
+            # Check if input looks like hex (only hex chars and spaces)
+            is_hex = all(c in '0123456789abcdefABCDEF ' for c in find)
+            find_bytes = bytes.fromhex(find.replace(" ", "")) if is_hex else find.encode()
+            idx = data.find(find_bytes)
+            if idx >= 0:
+                console.print(f"[green]✅ Found at offset 0x{idx:x}[/]")
+                # Show context
+                start = max(0, idx - 4)
+                end = min(len(data), idx + len(find_bytes) + 16)
+                console.print(f"  Context: {' '.join(f'{data[j]:02x}' for j in range(start, end))}")
+            else:
+                console.print("[yellow]⚠️  Not found[/]")
+            return
+    
+    # NOP patching (ARM64 NOP = 1F 20 03 D5)
+    if nop is not None and off is not None:
+        for i in range(nop):
+            data[off + i*4] = 0x1F
+            data[off + i*4 + 1] = 0x20
+            data[off + i*4 + 2] = 0x03
+            data[off + i*4 + 3] = 0xD5
+        console.print(f"[green]✅ NOP'd {nop} instruction(s) at 0x{off:x}[/]")
+        path.write_bytes(data)
+        return
+    
+    # Byte patching
+    if bytes is not None and off is not None:
+        patch_bytes = bytes.fromhex(bytes.replace(" ", ""))
+        for i, b in enumerate(patch_bytes):
+            if off + i < len(data):
+                data[off + i] = b
+        console.print(f"[green]✅ Patched {len(patch_bytes)} byte(s) at 0x{off:x}[/]")
+        # Show before/after
+        console.print(f"  Old: {' '.join(f'{data[j]:02x}' for j in range(off, min(off+len(patch_bytes), len(data))))}")
+        path.write_bytes(data)
+        return
+    
+    # String patch at offset
+    if string is not None and off is not None:
+        str_bytes = string.encode()
+        for i, b in enumerate(str_bytes):
+            if off + i < len(data):
+                data[off + i] = b
+        # Null terminate
+        if off + len(str_bytes) < len(data):
+            data[off + len(str_bytes)] = 0
+        console.print(f"[green]✅ Wrote string '{string}' at 0x{off:x}[/]")
+        path.write_bytes(data)
+        return
+    
+    console.print("[yellow]Usage: apkdev patch binary.so --options ...[/]")
+    console.print("  apkdev patch --help  for details")
+# ═══════════════════════════════════════════════════════════════
+#  SYSTEM COMMANDS
+# ═══════════════════════════════════════════════════════════════
+
+
+@cli.command("dart", help="Analyze Dart AOT snapshot in Flutter libapp.so")
+@click.argument("binary")
+@click.option("--classes", "-c", is_flag=True, help="Extract class/method names")
+@click.option("--strings", "-s", is_flag=True, help="Extract Dart strings")
+@click.option("--count", default=40, help="Max items to show")
+def _dart(binary, classes, strings, count):
+    """Analyze a Flutter app's Dart AOT snapshot (libapp.so).
+    Extracts class names, method names, and strings from Dart compiled code.
+    """
+    from pathlib import Path
+    import re
+    
+    path = Path(binary)
+    if not path.exists():
+        console.print(f"[red]File not found: {binary}[/]")
+        return
+    
+    data = path.read_bytes()
+    console.print(f"[bold cyan]Dart AOT Analysis: {path.name}[/]")
+    console.print(f"  Size: {len(data):,} bytes")
+    console.print()
+    
+    # Find Dart snapshot sections
+    markers = {
+        b'_kDartVmSnapshotData': 'VM Snapshot Data',
+        b'_kDartVmSnapshotInstructions': 'VM Snapshot Instructions',
+        b'_kDartIsolateSnapshotData': 'Isolate Snapshot Data',
+        b'_kDartIsolateSnapshotInstructions': 'Isolate Snapshot Instructions',
+        b'_kDartSnapshotBuildId': 'Build ID',
+    }
+    
+    found_any = False
+    for marker, desc in markers.items():
+        idx = data.find(marker)
+        if idx >= 0:
+            found_any = True
+            # Try to find the value after the marker
+            val_start = idx + len(marker)
+            # Look for null-terminated string or address
+            end = data.find(b'\x00', val_start, val_start + 200)
+            if end > 0:
+                val = data[val_start:end]
+                try:
+                    val_str = val.decode('ascii', errors='replace')
+                    console.print(f"  [green]{desc}:[/] {val_str}")
+                except:
+                    console.print(f"  [green]{desc}:[/] (binary data, {len(val)} bytes)")
+    
+    if not found_any:
+        console.print("  [yellow]No standard Dart snapshot markers found[/]")
+    
+    # Extract class names
+    if classes or not strings:
+        console.print()
+        console.print("[bold]Potential Dart identifiers:[/]")
+        # Find CamelCase identifiers
+        # In AOT snapshots, class/method names are often stored with length prefix
+        dart_ids = set()
+        # Pattern: look for strings that look like Dart names (CamelCase with underscores)
+        for m in re.finditer(rb'[A-Z][a-z]{1,10}[A-Z][a-zA-Z0-9_]{2,80}', data[:min(len(data), 2000000)]):
+            try:
+                s = m.group().decode('ascii')
+                if any(c.islower() for c in s[1:]):
+                    dart_ids.add(s)
+            except:
+                pass
+        
+        for name in sorted(dart_ids)[:count]:
+            console.print(f"  {name}")
+        if len(dart_ids) > count:
+            console.print(f"  ... and {len(dart_ids) - count} more")
+    
+    # Extract strings
+    if strings:
+        console.print()
+        console.print("[bold]Dart strings (readable):[/]")
+        dart_strs = set()
+        for m in re.finditer(rb'[\x20-\x7e]{8,}', data):
+            try:
+                s = m.group().decode('ascii')
+                if any(c.isupper() for c in s) and any(c.islower() for c in s):
+                    dart_strs.add(s)
+            except:
+                pass
+        
+        for s in sorted(dart_strs)[:count]:
+            console.print(f"  {s}")
+        if len(dart_strs) > count:
+            console.print(f"  ... and {len(dart_strs) - count} more")
+
+
+@cli.command("go", help="Analyze Go native library (.so)")
+@click.argument("binary")
+@click.option("--funcs", "-f", is_flag=True, help="Show exported Go functions")
+@click.option("--strings", "-s", is_flag=True, help="Extract Go strings")
+@click.option("--count", default=40, help="Max items to show")
+def _golang(binary, funcs, strings, count):
+    """Analyze a Go-compiled native library (libgojni.so, etc.).
+    Extracts Go function names, package paths, and strings.
+    """
+    from pathlib import Path
+    import subprocess, re
+    
+    path = Path(binary)
+    if not path.exists():
+        console.print(f"[red]File not found: {binary}[/]")
+        return
+    
+    data = path.read_bytes()
+    
+    # Check if it's Go by looking for Go runtime strings
+    is_go = b'Go' in data[:50] and b'gobackend' in data or b'go1.' in data or b'go.build' in data
+    go_hints = [b'Go build', b'go1.', b'gobackend', b'goid', b'goroutine']
+    go_score = sum(1 for h in go_hints if h in data)
+    
+    console.print(f"[bold cyan]Go Analysis: {path.name}[/]")
+    console.print(f"  Size: {len(data):,} bytes")
+    console.print(f"  Go confidence: {'✅ High' if go_score >= 3 else '⚠️ Low'} (score={go_score}/5)")
+    console.print()
+    
+    # Try to get exported functions from ELF
+    try:
+        r = subprocess.run(["readelf", "--dyn-syms", "--wide", str(path)],
+                          capture_output=True, text=True, timeout=10)
+        go_funcs = [l for l in r.stdout.split(chr(10)) if ' FUNC ' in l and 'gobackend' in l.lower()]
+        
+        if funcs or not strings:
+            console.print("[bold]Go functions (gobackend.*):[/]")
+            if go_funcs:
+                for line in go_funcs[:count]:
+                    # Extract the function name
+                    parts = line.split()
+                    if len(parts) >= 8:
+                        name = parts[-1]
+                        # Try to clean up the name
+                        if name.startswith('_cgoexp_'):
+                            # Extract the readable part
+                            readable = name.split('_proxy', 1)[-1] if '_proxy' in name else name
+                            console.print(f"  {readable}")
+                        else:
+                            console.print(f"  {name}")
+            else:
+                console.print("  [yellow]No gobackend functions found in dynamic symbols[/]")
+                # Show any function symbols
+                all_funcs = [l for l in r.stdout.split(chr(10)) if ' FUNC ' in l]
+                console.print(f"  Total function symbols: {len(all_funcs)}")
+                for line in all_funcs[:10]:
+                    parts = line.split()
+                    if len(parts) >= 8:
+                        console.print(f"  {parts[-1]}")
+    
+    except Exception as e:
+        console.print(f"  [red]Error: {e}[/]")
+    
+    # Extract Go strings
+    if strings:
+        console.print()
+        console.print("[bold]Go strings:[/]")
+        # Go strings are typically null-terminated ASCII
+        go_strs = set()
+        for m in re.finditer(rb'[\x20-\x7e]{6,}', data):
+            try:
+                s = m.group().decode('ascii')
+                if any(c.isupper() for c in s) and any(c.islower() for c in s):
+                    go_strs.add(s)
+            except:
+                pass
+        
+        # Filter to more interesting ones
+        interesting = [s for s in go_strs if any(k in s for k in ['download', 'quality', 'error', 'token', 'url', 'api', 'http'])]
+        for s in interesting[:count]:
+            console.print(f"  {s}")
+        if len(interesting) > count:
+            console.print(f"  ... and {len(interesting) - count} more")
+@cli.command("info", help="Show installed tool versions")
+def _info():
+    """Display all installed tool versions and SDK status."""
+    console.print(banner())
+    info()
+
+
+@cli.command("setup", help="Full one-command environment setup")
+def _setup():
+    """Auto-install ALL dependencies: tools, SDK, keystore, Python modules."""
+    console.print(banner())
+    setup()
+
+
+@cli.command("doctor", help="Check environment for missing dependencies")
+def doctor():
+    """Check what's installed and what's missing (cross-platform)."""
+    console.print(banner())
+    
+    import shutil
+    
+    plat = detect_platform()
+    console.print(f"[yellow]🔍 Checking environment... ({plat['platform_name']})[/]\n")
+    
+    # Platform-specific install hints
+    install_cmd = "apkdev setup"
+    if plat["pkg_install_cmd"]:
+        pm = " ".join(plat["pkg_install_cmd"])
+    else:
+        pm = "pkg install" if plat["is_termux"] else "apt-get install"
+    
+    all_checks = [
+        ("Build", [
+            ("java", f"{pm} {plat['java_pkg']}"),
+            ("kotlin", f"{pm} kotlin"),
+            ("gradle", f"{pm} gradle"),
+            ("aapt2", f"{pm} aapt2" if not plat["is_android"] else f"{pm} aapt2"),
+            ("apksigner", f"{pm} apksigner"),
+            ("zipalign", f"{pm} zipalign"),
+            ("adb", f"{pm} android-tools" if plat["is_termux"] else f"{pm} adb"),
+        ]),
+        ("Reverse Engineering", [
+            ("apktool", f"{pm} apktool"),
+            ("jadx", f"{pm} jadx"),
+            ("d2j-dex2jar", f"{pm} dex2jar" if plat["is_termux"] else "pip3 install pydex2"),
+            ("smali", install_cmd),
+            ("baksmali", install_cmd),
+            ("APKEditor", install_cmd),
+        ]),
+        ("Python", [
+            ("androguard", "pip3 install androguard"),
+        ]),
+    ]
+    
+    issues = []
+    
+    for group_name, tools in all_checks:
+        console.print(f"[bold]{group_name}[/]")
+        for cmd, hint in tools:
+            if shutil.which(cmd):
+                console.print(f"  [green]✅[/] {cmd}")
+            else:
+                console.print(f"  [red]❌[/] {cmd}")
+                issues.append(hint)
+        console.print()
+    
+    # SDK check
+    sdk = Path.home() / "android-sdk"
+    if sdk.exists() and (sdk / "platforms").exists():
+        plats = [p.name for p in (sdk / "platforms").iterdir()]
+        console.print(f"  [green]✅[/] Android SDK ({', '.join(plats)})")
+    else:
+        console.print(f"  [red]❌[/] Android SDK")
+        issues.append(install_cmd)
+    
+    # Summary
+    console.print()
+    if issues:
+        console.print(f"[yellow]⚠️  {len(issues)} issues to fix:[/]")
+        for issue in issues[:5]:
+            console.print(f"   • {issue}")
+        if len(issues) > 5:
+            console.print(f"   • ... and {len(issues)-5} more")
+        console.print(f"\n   Run: [bold cyan]apkdev setup[/] — auto-fix everything")
+    else:
+        console.print("[green]✅ Everything is ready![/]")
+
+
+@cli.command("completion", help="Generate shell completion script")
+@click.argument("shell", type=click.Choice(["bash", "zsh", "fish"]), default="bash")
+def _completion(shell):
+    """Generate and print shell completion script."""
+    scripts = {
+        "bash": 'eval "$(_APKDEV_COMPLETE=bash_source apkdev)"',
+        "zsh": 'eval "$(_APKDEV_COMPLETE=zsh_source apkdev)"',
+        "fish": 'eval (env _APKDEV_COMPLETE=fish_source apkdev)',
+    }
+    print(f"# Add to your ~/.{shell}rc:")
+    print(scripts.get(shell, scripts["bash"]))
+
+
+if __name__ == "__main__":
+    cli()