ascli.py

#!/usr/bin/env python3
"""ascli — AI-agent-native, token-efficient CLI for the Android Studio toolchain.

Operates everything Android Studio wraps: SDK packages, AVDs/emulator, ADB
devices, Gradle builds, APK inspection, project parsing, and the Android
Studio IDE itself. Zero config: SDK/JDK are auto-detected. stdout is compact
JSON (pointer style); large payloads are saved under ~/.hermes/ascli_output/
and referenced via the "f" key.

Usage:
  ascli env
  ascli sdk list|install <pkg...>|licenses
  ascli avd list|create|delete|start|stop|status
  ascli dev list|info|install|uninstall|launch|stop|shell|tap|swipe|text|key|
       scr|rec|ui|log|top|wait|pull|push|battery
  ascli build apk|test|tasks|clean|info
  ascli apk info|perms|manifest|sign
  ascli proj info
  ascli studio open|status

Global flags (before the subcommand): -s SERIAL, -p (pretty), -t SECONDS (timeout).
"""
import argparse, json, os, re, shutil, struct, subprocess, sys, time

OUT_DIR = os.path.expanduser("~/.hermes/ascli_output")
VERSION = "0.1.0"
COMPACT = dict(separators=(",", ":"), ensure_ascii=False)

# ---------------------------------------------------------------- discovery

def _detect_sdk():
    cands = [os.environ.get("ANDROID_HOME"), os.environ.get("ANDROID_SDK_ROOT"),
             os.path.expanduser("~/android-sdk"), os.path.expanduser("~/Android/Sdk"),
             "/opt/android-sdk", "/usr/local/android-sdk"]
    for c in cands:
        if c and os.path.isdir(os.path.join(c, "platform-tools")):
            return os.path.realpath(c)
    return None

def _detect_jdk(sdk):
    cands = [os.path.join(sdk, "jdk17") if sdk else None, os.environ.get("JAVA_HOME")]
    for c in cands:
        if c and os.path.isfile(os.path.join(c, "bin", "java")):
            return c
    for base in ["/usr/lib/jvm", "/usr/local/openjdk"]:
        if os.path.isdir(base):
            for d in sorted(os.listdir(base), reverse=True):
                p = os.path.join(base, d)
                if os.path.isfile(os.path.join(p, "bin", "java")):
                    return p
    return None

def _latest_build_tools(sdk):
    bt = os.path.join(sdk, "build-tools")
    if not os.path.isdir(bt):
        return None
    vers = [d for d in os.listdir(bt) if re.match(r"^\d", d)]
    return sorted(vers, key=lambda v: [int(x) for x in v.split(".")])[-1] if vers else None

def _tool(sdk, name, build_tools_only=False):
    """Resolve a tool binary: adb/aapt2/apksigner from platform-tools / build-tools; sdkmanager etc from cmdline-tools."""
    if not sdk:
        return None
    if name == "adb":
        p = os.path.join(sdk, "platform-tools", "adb")
    elif name in ("aapt2", "apksigner", "zipalign", "d8"):
        bt = _latest_build_tools(sdk)
        if not bt:
            return None
        p = os.path.join(sdk, "build-tools", bt, name)
    elif name in ("sdkmanager", "avdmanager", "apkanalyzer", "lint"):
        p = os.path.join(sdk, "cmdline-tools", "latest", "bin", name)
        if not os.path.isfile(p):
            # older layout: cmdline-tools/<ver>/bin
            ct = os.path.join(sdk, "cmdline-tools")
            if os.path.isdir(ct):
                for d in sorted(os.listdir(ct), reverse=True):
                    cand = os.path.join(ct, d, "bin", name)
                    if os.path.isfile(cand):
                        return cand
            return None
    elif name == "emulator":
        p = os.path.join(sdk, "emulator", "emulator")
    else:
        return None
    return p if os.path.isfile(p) else None

def _gradle_dists(sdk):
    g = os.path.join(sdk, "gradle")
    if not os.path.isdir(g):
        return []
    out = []
    for d in sorted(os.listdir(g), reverse=True):
        b = os.path.join(g, d, "bin", "gradle")
        if os.path.isfile(b):
            out.append((d, b))
    # numeric version sort — lexicographic puts 8.7 AFTER 8.11.1
    out.sort(key=lambda t: [int(x) for x in re.findall(r"\d+", t[0])], reverse=True)
    return out

# ---------------------------------------------------------------- helpers

def _run(cmd, timeout=60, cwd=None, env=None, input_data=None, binary=False):
    e = dict(os.environ)
    if env:
        e.update(env)
    try:
        p = subprocess.run(cmd, capture_output=True, timeout=timeout, cwd=cwd,
                           env=e, input=input_data)
        out = p.stdout if binary else p.stdout.decode("utf-8", "replace")
        err = p.stderr.decode("utf-8", "replace") if not binary else p.stderr
        return p.returncode, out, err
    except subprocess.TimeoutExpired:
        return -1, "", "timeout after %ds" % timeout
    except FileNotFoundError:
        return -2, "", "command not found: %s" % cmd[0]

def _save(name, text):
    os.makedirs(OUT_DIR, exist_ok=True)
    f = os.path.join(OUT_DIR, "%s_%d.txt" % (name, int(time.time())))
    with open(f, "w", encoding="utf-8") as fh:
        fh.write(text)
    return f

def _clip(text, n=20000):
    text = text.strip()
    return text if len(text) <= n else text[:n] + "\n...[truncated %d chars]" % (len(text) - n)

def _err(msg, code=1):
    sys.stdout.write(json.dumps({"ok": False, "e": msg}, **COMPACT) + "\n")
    sys.exit(code)

def _emit(d, pretty=False):
    sys.stdout.write(json.dumps(d, indent=2 if pretty else None, **COMPACT) + "\n")

def _pick_serial(args, devs):
    if args.serial:
        return args.serial
    if len(devs) == 1:
        return devs[0]
    if len(devs) > 1:
        _err("multiple devices %s — pass -s SERIAL" % devs)
    _err("no devices connected")

def _devices(adb):
    rc, out, _ = _run([adb, "devices"])
    devs = []
    for line in out.splitlines()[1:]:
        parts = line.split()
        if len(parts) >= 2 and parts[1] == "device":
            devs.append(parts[0])
    return devs

def _png_size(p):
    try:
        with open(p, "rb") as f:
            head = f.read(24)
        if head[:8] != b"\x89PNG\r\n\x1a\n":
            return None
        return struct.unpack(">II", head[16:24])
    except Exception:
        return None

def _parse_badging(badging):
    d = {}
    perms = []
    for line in badging.splitlines():
        if line.startswith("package:"):
            m = re.search(r"name='([^']+)'", line)
            if m: d["pkg"] = m.group(1)
            m = re.search(r"versionCode='(\d+)'", line)
            if m: d["vc"] = int(m.group(1))
            m = re.search(r"versionName='([^']*)'", line)
            if m: d["vn"] = m.group(1)
        elif line.startswith("sdkVersion:"):
            d["min"] = line.split("'")[1] if "'" in line else line.split(":")[1].strip()
        elif line.startswith("targetSdkVersion:"):
            d["tgt"] = line.split("'")[1] if "'" in line else line.split(":")[1].strip()
        elif line.startswith("application-label:"):
            d["label"] = line.split("'")[1]
        elif line.startswith("launchable-activity:"):
            m = re.search(r"name='([^']+)'", line)
            if m: d["act"] = m.group(1)
        elif line.startswith("uses-permission:"):
            m = re.search(r"name='([^']+)'", line)
            if m: perms.append(m.group(1))
        elif line.startswith("application:") and "icon=" in line:
            m = re.search(r"icon='([^']+)'", line)
            if m: d["icon"] = m.group(1)
        elif line.startswith("native-code:"):
            m = re.search(r"'([^']+)'", line)
            if m: d["nat"] = m.group(1)
    if perms:
        d["perms"] = perms
    return d

def _env_base(sdk, jdk):
    env = {}
    if jdk:
        env["JAVA_HOME"] = jdk
        env["PATH"] = os.path.join(jdk, "bin") + os.pathsep + env.get("PATH", os.environ.get("PATH", ""))
    if sdk:
        env["ANDROID_HOME"] = sdk
        env["ANDROID_SDK_ROOT"] = sdk
    return env

def _resolve_project(d):
    d = os.path.abspath(d or os.getcwd())
    if os.path.isfile(os.path.join(d, "settings.gradle")) or os.path.isfile(os.path.join(d, "settings.gradle.kts")) or \
       os.path.isfile(os.path.join(d, "build.gradle")) or os.path.isfile(os.path.join(d, "build.gradle.kts")) or \
       os.path.isfile(os.path.join(d, "build.gradle")) is False and os.path.isfile(os.path.join(d, "build.gradle.kts")):
        return d
    return d

def _gradle_cmd(sdk, project):
    gw = os.path.join(project, "gradlew")
    if os.path.isfile(gw):
        return [gw]
    dists = _gradle_dists(sdk)
    if not dists:
        _err("no gradle wrapper (%s/gradlew) and no gradle dist under %s/gradle" % (project, sdk))
    return [dists[0][1]]

# ---------------------------------------------------------------- commands

def cmd_env(args, sdk, jdk, pretty):
    adb = _tool(sdk, "adb")
    devs = _devices(adb) if adb else []
    aapt2 = _tool(sdk, "aapt2")
    avdmanager = _tool(sdk, "avdmanager")
    emu = _tool(sdk, "emulator")
    avds = []
    if emu:
        rc, out, _ = _run([emu, "-list-avds"], timeout=20)
        avds = [l.strip() for l in out.splitlines() if l.strip()]
    elif avdmanager:
        rc, out, _ = _run([avdmanager, "list", "avd"], timeout=30, env=_env_base(sdk, jdk))
        avds = re.findall(r"Name:\s*(\S+)", out)
    _emit({
        "ok": True, "sdk": sdk, "jdk": jdk, "bt": _latest_build_tools(sdk),
        "tools": {t: bool(_tool(sdk, t)) for t in
                  ["adb", "aapt2", "apksigner", "avdmanager", "sdkmanager", "emulator", "apkanalyzer"]},
        "gradle": [d for d, _ in _gradle_dists(sdk)],
        "devs": devs, "avds": avds, "studio": bool(_find_studio()), "v": VERSION,
    }, pretty)

def cmd_sdk(args, sdk, jdk, pretty):
    sdkmanager = _tool(sdk, "sdkmanager")
    if not sdkmanager:
        _err("sdkmanager not found under %s/cmdline-tools" % sdk)
    env = _env_base(sdk, jdk)
    if args.action == "list":
        rc, out, err = _run([sdkmanager, "--list_installed"], timeout=120, env=env)
        if rc != 0:
            _err(err.strip() or "sdkmanager failed rc=%d" % rc)
        pkgs = []
        for line in out.splitlines():
            m = re.match(r"\s*([\w\-;\.\d]+)\s+\|\s*(\S+)", line)
            if m and m.group(1) not in ("Path", "-------"):
                pkgs.append({"p": m.group(1), "r": m.group(2)})
        _emit({"ok": True, "n": len(pkgs), "pkgs": pkgs}, pretty)
    elif args.action == "install":
        if not args.packages:
            _err("sdk install needs at least one package (e.g. 'emulator', 'system-images;android-34;google_apis;x86_64')")
        rc, out, err = _run([sdkmanager] + args.packages, timeout=args.timeout, env=env, input_data=b"y\n" * 50)
        if rc != 0:
            _err(_clip(err + out, 4000) or "sdkmanager install failed rc=%d" % rc)
        _emit({"ok": True, "installed": args.packages}, pretty)
    elif args.action == "licenses":
        rc, out, err = _run([sdkmanager, "--licenses"], timeout=args.timeout, env=env, input_data=b"y\n" * 200)
        _emit({"ok": rc == 0, "e": _clip(err, 1500) if rc else None, "n": 0}, pretty)

def _avd_list(sdk, jdk):
    emu = _tool(sdk, "emulator")
    if emu:
        rc, out, _ = _run([emu, "-list-avds"], timeout=20)
        return [l.strip() for l in out.splitlines() if l.strip()]
    avdmanager = _tool(sdk, "avdmanager")
    if avdmanager:
        rc, out, _ = _run([avdmanager, "list", "avd"], timeout=30, env=_env_base(sdk, jdk))
        return re.findall(r"Name:\s*(\S+)", out)
    return []

def cmd_avd(args, sdk, jdk, pretty):
    avdmanager = _tool(sdk, "avdmanager")
    emu = _tool(sdk, "emulator")
    adb = _tool(sdk, "adb")
    env = _env_base(sdk, jdk)
    if args.action == "list":
        _emit({"ok": True, "avds": _avd_list(sdk, jdk)}, pretty)
    elif args.action == "create":
        if not avdmanager:
            _err("avdmanager not found — install cmdline-tools")
        if not args.name or not args.image:
            _err("avd create needs --name and --image (system image pkg, e.g. system-images;android-34;google_apis;x86_64)")
        cmd = [avdmanager, "create", "avd", "-n", args.name, "-k", args.image, "--force"]
        if args.device:
            cmd += ["-d", args.device]
        if args.sdcard:
            cmd += ["--sdcard", args.sdcard]
        rc, out, err = _run(cmd, timeout=args.timeout, env=env, input_data=b"no\n")  # "custom hardware profile? [no]"
        if rc != 0:
            _err(_clip(err + out, 3000) or "avd create failed rc=%d" % rc)
        _emit({"ok": True, "name": args.name, "img": args.image}, pretty)
    elif args.action == "delete":
        if not avdmanager:
            _err("avdmanager not found")
        rc, out, err = _run([avdmanager, "delete", "avd", "-n", args.name], timeout=60, env=env)
        if rc != 0:
            _err(_clip(err, 1500) or "avd delete failed rc=%d" % rc)
        _emit({"ok": True, "deleted": args.name}, pretty)
    elif args.action == "start":
        if not emu:
            _err("emulator package not installed — run: ascli sdk install emulator 'system-images;android-34;google_apis;x86_64'")
        if args.name not in _avd_list(sdk, jdk):
            _err("AVD '%s' not found" % args.name)
        if not os.path.exists("/dev/kvm") and not args.force:
            _err("no /dev/kvm — x86_64 emulation requires hardware acceleration; "
                 "the emulator refuses to boot (QEMU TCG fallback removed). Enable "
                 "nested virtualization / install KVM, or pass --force to attempt "
                 "a very slow TCG boot anyway.")
        cmd = [emu, "-avd", args.name]
        if args.headless:
            cmd += ["-no-window", "-gpu", "swiftshader_indirect", "-no-audio", "-no-boot-anim"]
        if args.no_snapshot:
            cmd += ["-no-snapshot"]
        p = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                             start_new_session=True, env=dict(os.environ, **env))
        serial = None
        if args.wait:
            deadline = time.time() + args.timeout
            last = ""
            while time.time() < deadline:
                devs = _devices(adb)
                for d in devs:
                    if d.startswith("emulator-"):
                        serial = d
                        rc2, boot, _ = _run([adb, "-s", d, "shell", "getprop", "sys.boot_completed"], timeout=15)
                        if boot.strip() == "1":
                            _emit({"ok": True, "pid": p.pid, "serial": d, "booted": True, "t": round(time.time() - (time.time() - args.wait_elapsed), 1)}, pretty)
                            return
                time.sleep(2)
            _emit({"ok": False, "pid": p.pid, "serial": serial, "booted": False,
                   "e": "emulator started but boot not completed in %ds" % args.timeout}, pretty)
        else:
            _emit({"ok": True, "pid": p.pid, "started": True}, pretty)
    elif args.action == "stop":
        serial = args.serial
        if not serial:
            for d in _devices(adb):
                if d.startswith("emulator-"):
                    serial = d
                    break
        if not serial:
            _err("no emulator serial found")
        rc, out, err = _run([adb, "-s", serial, "emu", "kill"], timeout=20)
        _emit({"ok": rc == 0, "serial": serial, "e": _clip(err, 1000) if rc else None}, pretty)
    elif args.action == "status":
        serial = args.serial
        if not serial:
            for d in _devices(adb):
                if d.startswith("emulator-"):
                    serial = d
                    break
        if not serial:
            _emit({"ok": True, "running": False, "booted": False}, pretty)
            return
        rc, boot, _ = _run([adb, "-s", serial, "shell", "getprop", "sys.boot_completed"], timeout=15)
        _emit({"ok": True, "running": True, "serial": serial, "booted": boot.strip() == "1"}, pretty)

def _serial_arg(p):
    p.add_argument("-s", "--serial", help="device serial (auto-pick when exactly one device)")

def cmd_dev(args, sdk, jdk, pretty):
    adb = _tool(sdk, "adb")
    if not adb:
        _err("adb not found under %s/platform-tools" % sdk)
    a = args.action
    if a == "list":
        rc, out, _ = _run([adb, "devices"])
        rows = []
        for line in out.splitlines()[1:]:
            parts = line.split()
            if len(parts) >= 2:
                rows.append({"s": parts[0], "st": parts[1]})
        _emit({"ok": True, "n": len(rows), "devs": rows}, pretty)
        return
    if a == "wait":
        rc, out, err = _run([adb, "wait-for-device"], timeout=args.timeout)
        if rc != 0:
            _err(_clip(err, 1000) or "adb wait-for-device failed")
        serial = _pick_serial(args, _devices(adb))
        deadline = time.time() + args.timeout
        while time.time() < deadline:
            rc2, boot, _ = _run([adb, "-s", serial, "shell", "getprop", "sys.boot_completed"], timeout=15)
            if boot.strip() == "1":
                _emit({"ok": True, "serial": serial, "booted": True}, pretty)
                return
            time.sleep(2)
        _emit({"ok": True, "serial": serial, "booted": False, "e": "device online but not boot-completed in %ds" % args.timeout}, pretty)
        return
    devs = _devices(adb)
    serial = _pick_serial(args, devs)
    pre = [adb, "-s", serial]
    if a == "info":
        props = ["ro.product.model", "ro.product.manufacturer", "ro.build.version.release",
                 "ro.build.version.sdk", "ro.product.cpu.abi"]
        d = {"ok": True, "serial": serial}
        for p in props:
            rc, out, _ = _run(pre + ["shell", "getprop", p], timeout=15)
            d[p.split(".")[-1]] = out.strip()
        rc, wm, _ = _run(pre + ["shell", "wm", "size"], timeout=15)
        m = re.search(r"(\d+)x(\d+)", wm)
        if m:
            d["w"], d["h"] = int(m.group(1)), int(m.group(2))
        rc, dens, _ = _run(pre + ["shell", "wm", "density"], timeout=15)
        m = re.search(r"(\d+)", dens)
        if m:
            d["dpi"] = int(m.group(1))
        _emit(d, pretty)
    elif a == "install":
        if not args.apk:
            _err("dev install needs an APK path")
        cmd = pre + ["install"]
        if args.replace:
            cmd.append("-r")
        cmd.append(args.apk)
        rc, out, err = _run(cmd, timeout=args.timeout)
        ok = rc == 0 and "Success" in out
        _emit({"ok": ok, "serial": serial, "r": _clip(out + err, 2000)}, pretty)
    elif a == "uninstall":
        if not args.pkg:
            _err("dev uninstall needs a package name")
        rc, out, err = _run(pre + ["uninstall", args.pkg], timeout=60)
        ok = rc == 0 and "Success" in out
        _emit({"ok": ok, "serial": serial, "r": _clip(out + err, 1000)}, pretty)
    elif a == "launch":
        if not args.pkg:
            _err("dev launch needs a package name")
        act = args.act
        if not act:
            rc, out, _ = _run(pre + ["shell", "cmd", "package", "resolve-activity", "--brief", args.pkg], timeout=15)
            line = out.strip().splitlines()[-1] if out.strip() else ""
            if "/" in line:
                act = line.split()[-1]
        if act:
            rc, out, err = _run(pre + ["shell", "am", "start", "-n", act], timeout=20)
        else:
            rc, out, err = _run(pre + ["shell", "am", "start", "-a", "android.intent.action.MAIN",
                                       "-c", "android.intent.category.LAUNCHER", "-p", args.pkg], timeout=20)
        ok = rc == 0 and "Error" not in out
        _emit({"ok": ok, "serial": serial, "pkg": args.pkg, "act": act,
               "r": _clip(out + err, 1500)}, pretty)
    elif a == "stop":
        if not args.pkg:
            _err("dev stop needs a package name")
        rc, out, err = _run(pre + ["shell", "am", "force-stop", args.pkg], timeout=15)
        _emit({"ok": rc == 0, "serial": serial, "pkg": args.pkg, "e": _clip(err, 800) if rc else None}, pretty)
    elif a == "shell":
        cmd = pre + ["shell"] + args.cmd
        rc, out, err = _run(cmd, timeout=args.timeout)
        if rc != 0:
            _err(_clip(err, 2000) or "shell rc=%d" % rc)
        if len(out) > 20000:
            f = _save("shell", out)
            _emit({"ok": True, "serial": serial, "f": f, "n": len(out)}, pretty)
        else:
            _emit({"ok": True, "serial": serial, "r": out.strip()}, pretty)
    elif a in ("tap", "swipe", "text", "key"):
        if a == "tap":
            cmd = pre + ["shell", "input", "tap", str(args.x), str(args.y)]
        elif a == "swipe":
            cmd = pre + ["shell", "input", "swipe", str(args.x1), str(args.y1), str(args.x2), str(args.y2)]
            if args.ms:
                cmd.append(str(args.ms))
        elif a == "text":
            cmd = pre + ["shell", "input", "text", args.text]
        else:
            cmd = pre + ["shell", "input", "keyevent", str(args.keycode)]
        rc, out, err = _run(cmd, timeout=20)
        _emit({"ok": rc == 0, "serial": serial, "a": a, "e": _clip(err, 800) if rc else None}, pretty)
    elif a == "scr":
        f = os.path.join(OUT_DIR, "scr_%d.png" % int(time.time()))
        os.makedirs(OUT_DIR, exist_ok=True)
        rc, out, err = _run(pre + ["exec-out", "screencap", "-p"], timeout=30, binary=True)
        if rc != 0:
            _err(_clip(err, 1000) or "screencap failed")
        with open(f, "wb") as fh:
            fh.write(out)
        w, h = _png_size(f)
        _emit({"ok": True, "serial": serial, "f": f, "w": w, "h": h, "b": len(out)}, pretty)
    elif a == "rec":
        if not args.secs:
            _err("dev rec needs --secs N")
        remote = "/sdcard/ascli_rec_%d.mp4" % int(time.time())
        rc, out, err = _run(pre + ["shell", "screenrecord", "--time-limit", str(args.secs), remote], timeout=args.timeout + 30)
        if rc != 0:
            _err(_clip(out + err, 1500) or "screenrecord failed")
        f = os.path.join(OUT_DIR, "rec_%d.mp4" % int(time.time()))
        os.makedirs(OUT_DIR, exist_ok=True)
        rc, out, err = _run(pre + ["pull", remote, f], timeout=120)
        _emit({"ok": rc == 0, "serial": serial, "f": f, "secs": args.secs, "e": _clip(err, 800) if rc else None}, pretty)
    elif a == "ui":
        rc, out, err = _run(pre + ["exec-out", "uiautomator", "dump", "/dev/tty"], timeout=30)
        if rc != 0:
            _err(_clip(out + err, 1500) or "uiautomator dump failed")
        xml = out[out.find("<"):]
        end = xml.find("</hierarchy>")  # dump appends 'UI hierchary dumped to: /dev/tty' after root
        if end != -1:
            xml = xml[:end + len("</hierarchy>")]
        f = _save("ui", xml)
        nodes, err2 = _parse_ui_xml(xml)
        _emit({"ok": True, "serial": serial, "f": f, "n": len(nodes), "nodes": nodes,
               "e": err2}, pretty)
    elif a == "log":
        cmd = pre + ["logcat", "-d", "-v", "brief"]
        if args.tag:
            cmd += ["-s", args.tag]
        elif args.level:
            cmd += ["*:%s" % args.level[0]]
        rc, out, err = _run(cmd, timeout=args.timeout)
        if rc != 0:
            _err(_clip(err, 1000) or "logcat failed")
        lines = out.rstrip("\n").splitlines()
        f = _save("log", out)
        tail = "\n".join(lines[-args.lines:]) if args.lines else out.strip()
        _emit({"ok": True, "serial": serial, "f": f, "n": len(lines), "tail": _clip(tail, 8000)}, pretty)
    elif a == "top":
        rc, out, _ = _run(pre + ["shell", "dumpsys", "window", "displays"], timeout=20)
        m = re.search(r"mCurrentFocus=(Window\{[^}]*\}|\S+)", out)
        focus = (m.group(1).strip("{}") if m and m.group(1).startswith("Window") else (m.group(1) if m else None))
        _emit({"ok": True, "serial": serial, "focus": focus}, pretty)
    elif a == "pull":
        if not args.remote or not args.local:
            _err("dev pull needs REMOTE and LOCAL paths")
        rc, out, err = _run(pre + ["pull", args.remote, args.local], timeout=120)
        _emit({"ok": rc == 0, "serial": serial, "r": _clip(out + err, 1000)}, pretty)
    elif a == "push":
        if not args.local or not args.remote:
            _err("dev push needs LOCAL and REMOTE paths")
        rc, out, err = _run(pre + ["push", args.local, args.remote], timeout=120)
        _emit({"ok": rc == 0, "serial": serial, "r": _clip(out + err, 1000)}, pretty)
    elif a == "battery":
        rc, out, _ = _run(pre + ["shell", "dumpsys", "battery"], timeout=20)
        d = {"ok": True, "serial": serial}
        for key in ("level", "status", "temperature"):
            m = re.search(r"^\s*%s:\s*(\S+)" % key, out, re.M)
            if m:
                d[key] = m.group(1)
        _emit(d, pretty)

def _parse_ui_xml(xml):
    import xml.etree.ElementTree as ET
    nodes, err = [], None
    try:
        root = ET.fromstring(xml)
        def walk(el):
            if len(nodes) >= 300:
                return
            b = (el.get("bounds") or "")[1:-1].split("][")
            coords = []
            for part in b[:1]:
                for v in part.split(","):
                    try: coords.append(int(v.strip()))
                    except ValueError: pass
            nodes.append({
                "cl": (el.get("class") or "").rsplit(".", 1)[-1],
                "t": (el.get("text") or "")[:60],
                "d": (el.get("content-desc") or "")[:60],
                "b": [int(v) for v in re.findall(r"-?\d+", el.get("bounds") or "")][:4],
                "c": el.get("clickable") == "true",
            })
            for child in el:
                walk(child)
        walk(root)
    except ET.ParseError as ex:
        err = "xml parse error: %s" % ex
    return nodes, err

def cmd_build(args, sdk, jdk, pretty):
    project = _resolve_project(args.dir)
    g = _gradle_cmd(sdk, project)
    env = _env_base(sdk, jdk)
    if args.action == "apk":
        variant = (args.variant or "debug").capitalize()
        task = "assemble%s" % variant
        rc, out, err = _run(g + ["-p", project, task, "--console=plain"], timeout=args.timeout, env=env)
        apks = []
        base = os.path.join(project, "app", "build", "outputs", "apk")
        if os.path.isdir(base):
            for root, _, files in os.walk(base):
                for fn in files:
                    if fn.endswith(".apk"):
                        apks.append(os.path.join(root, fn))
        ok = rc == 0 and "BUILD SUCCESSFUL" in out
        _emit({"ok": ok, "project": project, "task": task, "apks": apks,
               "r": _clip(out[-3000:] + err[-1000:], 4000)}, pretty)
    elif args.action == "test":
        rc, out, err = _run(g + ["-p", project, "test", "--console=plain"], timeout=args.timeout, env=env)
        ok = rc == 0 and "BUILD SUCCESSFUL" in out
        report = os.path.join(project, "app", "build", "reports", "tests")
        _emit({"ok": ok, "project": project, "report": report if os.path.isdir(report) else None,
               "r": _clip(out[-3000:] + err[-1000:], 4000)}, pretty)
    elif args.action == "clean":
        rc, out, err = _run(g + ["-p", project, "clean", "--console=plain"], timeout=args.timeout, env=env)
        _emit({"ok": rc == 0, "project": project, "r": _clip(out[-1500:] + err[-1000:], 2500)}, pretty)
    elif args.action == "tasks":
        rc, out, err = _run(g + ["-p", project, "tasks", "--all", "--console=plain"], timeout=args.timeout, env=env)
        f = _save("tasks", out + err)
        groups = re.findall(r"^([A-Za-z ]+?) tasks$", out, re.M)
        _emit({"ok": True, "project": project, "f": f, "groups": groups[:20]}, pretty)
    elif args.action == "info":
        _emit(_proj_info(project), pretty)

def cmd_apk(args, sdk, jdk, pretty):
    if not args.apk or not os.path.isfile(args.apk):
        _err("apk file not found: %r" % args.apk)
    aapt2 = _tool(sdk, "aapt2")
    if not aapt2:
        _err("aapt2 not found under %s/build-tools" % sdk)
    a = args.action
    if a in ("info", "perms"):
        rc, out, err = _run([aapt2, "dump", "badging", args.apk], timeout=60)
        if rc != 0:
            _err(_clip(err, 1500) or "aapt2 dump badging failed")
        d = _parse_badging(out)
        d.update({"ok": True, "apk": os.path.basename(args.apk), "b": os.path.getsize(args.apk)})
        _emit(d, pretty)
    elif a == "manifest":
        rc, out, err = _run([aapt2, "dump", "xmltree", "--file", "AndroidManifest.xml", args.apk], timeout=60)
        if rc != 0:
            _err(_clip(err, 1500) or "aapt2 dump xmltree failed")
        f = _save("manifest", out)
        _emit({"ok": True, "f": f, "n": len(out)}, pretty)
    elif a == "sign":
        apksigner = _tool(sdk, "apksigner")
        if not apksigner:
            _err("apksigner not found under %s/build-tools" % sdk)
        rc, out, err = _run([apksigner, "verify", "--print-certs", "--verbose", args.apk], timeout=60, env=_env_base(sdk, jdk))
        cert = None
        m = re.search(r"Signer #1 certificate DN:\s*(\S.*)", out)
        if m:
            cert = {"dn": m.group(1)}
            m2 = re.search(r"Signer #1 certificate SHA-256 digest:\s*(\S+)", out)
            if m2:
                cert["sha256"] = m2.group(1)
        _emit({"ok": rc == 0, "v1": "v1 scheme" in out, "v2": "v2 scheme" in out,
               "v3": "v3 scheme" in out, "cert": cert,
               "e": _clip(err, 1000) if rc else None}, pretty)

def _proj_info(project):
    d = {"ok": True, "dir": project}
    sets = [f for f in ("settings.gradle", "settings.gradle.kts") if os.path.isfile(os.path.join(project, f))]
    d["wrapper"] = None
    wp = os.path.join(project, "gradle", "wrapper", "gradle-wrapper.properties")
    if os.path.isfile(wp):
        m = re.search(r"distributionUrl=.*gradle-([\d\.]+)-", open(wp).read())
        if m:
            d["wrapper"] = m.group(1)
    mods = []
    if sets:
        text = open(os.path.join(project, sets[0])).read()
        for m in re.finditer(r"['\"](:?[\w:]+)['\"]", text):
            mods.append(m.group(1))
    d["modules"] = sorted(set(mods))[:30]
    app_id = sdk_min = sdk_tgt = None
    for bf in ("app/build.gradle", "app/build.gradle.kts", "build.gradle", "build.gradle.kts"):
        p = os.path.join(project, bf)
        if os.path.isfile(p):
            text = open(p).read()
            m = re.search(r"applicationId\s+[\"']([^\"']+)[\"']", text)
            if m: app_id = m.group(1)
            m = re.search(r"minSdk\w*\s+(\d+)", text)
            if m: sdk_min = m.group(1)
            m = re.search(r"targetSdk\w*\s+(\d+)", text)
            if m: sdk_tgt = m.group(1)
            break
    d["appId"] = app_id
    d["minSdk"] = sdk_min
    d["targetSdk"] = sdk_tgt
    return d

def cmd_proj(args, sdk, jdk, pretty):
    project = _resolve_project(args.dir)
    _emit(_proj_info(project), pretty)

def _find_studio():
    cands = ["/opt/android-studio/bin/studio.sh", "/usr/local/android-studio/bin/studio.sh",
             os.path.expanduser("~/android-studio/bin/studio.sh"),
             os.path.expanduser("~/.local/android-studio/bin/studio.sh")]
    for c in cands:
        if os.path.isfile(c):
            return c
    return None

def cmd_studio(args, sdk, jdk, pretty):
    studio = _find_studio()
    if args.action == "open":
        if not studio:
            _err("Android Studio not found (tried: /opt/android-studio, ~/android-studio, ~/.local/android-studio)")
        project = os.path.abspath(args.dir or os.getcwd())
        if not os.path.isdir(project):
            _err("project dir not found: %s" % project)
        p = subprocess.Popen([studio, project], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                             start_new_session=True)
        _emit({"ok": True, "studio": studio, "pid": p.pid, "project": project}, pretty)
    else:  # status
        if not studio:
            _emit({"ok": True, "installed": False, "studio": None}, pretty)
            return
        rc, out, _ = _run(["pgrep", "-f", "android-studio"], timeout=10)
        pids = [l.strip() for l in out.splitlines() if l.strip()] if rc == 0 else []
        _emit({"ok": True, "installed": True, "studio": studio, "running": bool(pids), "pids": pids}, pretty)

# ---------------------------------------------------------------- main

def main():
    ap = argparse.ArgumentParser(prog="ascli", description="Android Studio toolchain CLI (AI-agent-native, JSON out)")
    ap.add_argument("-s", "--serial", help="device serial")
    ap.add_argument("-p", "--pretty", action="store_true", help="pretty-print JSON")
    ap.add_argument("-t", "--timeout", type=int, default=300, help="subprocess timeout seconds (default 300)")
    ap.add_argument("--version", action="version", version=VERSION)
    sub = ap.add_subparsers(dest="group", required=True)

    p = sub.add_parser("env", help="one-shot environment report")
    p.set_defaults(action="env")

    p = sub.add_parser("sdk", help="SDK package management")
    s = p.add_subparsers(dest="action", required=True)
    s.add_parser("list", help="installed packages")
    si = s.add_parser("install", help="install SDK packages (e.g. emulator, system-images;android-34;google_apis;x86_64)")
    si.add_argument("packages", nargs="+")
    s.add_parser("licenses", help="accept all SDK licenses")

    p = sub.add_parser("avd", help="Android Virtual Device management")
    a = p.add_subparsers(dest="action", required=True)
    a.add_parser("list", help="list AVDs")
    ac = a.add_parser("create", help="create AVD")
    ac.add_argument("--name", required=True)
    ac.add_argument("--image", required=True, help="system image package, e.g. system-images;android-34;google_apis;x86_64")
    ac.add_argument("--device", help="device profile id (avdmanager list device)")
    ac.add_argument("--sdcard", help="e.g. 512M")
    ad = a.add_parser("delete", help="delete AVD")
    ad.add_argument("name")
    st = a.add_parser("start", help="boot emulator")
    st.add_argument("name")
    st.add_argument("--headless", action="store_true", help="-no-window + swiftshader")
    st.add_argument("--no-snapshot", action="store_true")
    st.add_argument("--wait", action="store_true", help="block until boot_completed")
    st.add_argument("--force", action="store_true", help="attempt boot without /dev/kvm (TCG, very slow)")
    st.add_argument("--wait-elapsed", type=float, default=0.0, help=argparse.SUPPRESS)
    sp = a.add_parser("stop", help="kill emulator")
    _serial_arg(sp)
    sq = a.add_parser("status", help="emulator boot status")
    _serial_arg(sq)

    p = sub.add_parser("dev", help="ADB device operations")
    d = p.add_subparsers(dest="action", required=True)
    d.add_parser("list", help="connected devices")
    dw = d.add_parser("wait", help="wait for device + boot")
    di = d.add_parser("info", help="device properties")
    _serial_arg(di)
    dins = d.add_parser("install", help="install APK")
    _serial_arg(dins)
    dins.add_argument("apk")
    dins.add_argument("--replace", action="store_true")
    dun = d.add_parser("uninstall", help="uninstall package")
    _serial_arg(dun)
    dun.add_argument("pkg")
    dla = d.add_parser("launch", help="start app (auto-resolves launcher activity)")
    _serial_arg(dla)
    dla.add_argument("pkg")
    dla.add_argument("--act", help="explicit component pkg/.Activity")
    dstop = d.add_parser("stop", help="force-stop app")
    _serial_arg(dstop)
    dstop.add_argument("pkg")
    dsh = d.add_parser("shell", help="run shell command")
    _serial_arg(dsh)
    dsh.add_argument("cmd", nargs=argparse.REMAINDER)
    dtap = d.add_parser("tap", help="tap x y")
    _serial_arg(dtap)
    dtap.add_argument("x", type=int); dtap.add_argument("y", type=int)
    dsw = d.add_parser("swipe", help="swipe x1 y1 x2 y2 [--ms]")
    _serial_arg(dsw)
    dsw.add_argument("x1", type=int); dsw.add_argument("y1", type=int)
    dsw.add_argument("x2", type=int); dsw.add_argument("y2", type=int)
    dsw.add_argument("--ms", type=int, default=300)
    dtx = d.add_parser("text", help="type text")
    _serial_arg(dtx)
    dtx.add_argument("text")
    dkey = d.add_parser("key", help="send keycode (e.g. 4=back, 3=home, 66=enter)")
    _serial_arg(dkey)
    dkey.add_argument("keycode", type=int)
    dsc = d.add_parser("scr", help="screenshot")
    _serial_arg(dsc)
    drc = d.add_parser("rec", help="screenrecord N seconds")
    _serial_arg(drc)
    drc.add_argument("--secs", type=int, required=True)
    dui = d.add_parser("ui", help="uiautomator hierarchy (bounded JSON)")
    _serial_arg(dui)
    dlg = d.add_parser("log", help="logcat (last N lines)")
    _serial_arg(dlg)
    dlg.add_argument("--tag", help="filter by tag (e.g. ActivityManager)")
    dlg.add_argument("--level", choices=["v", "d", "i", "w", "e"], help="min level")
    dlg.add_argument("--lines", type=int, default=60)
    dtop = d.add_parser("top", help="focused window/activity")
    _serial_arg(dtop)
    dpl = d.add_parser("pull", help="pull REMOTE LOCAL")
    _serial_arg(dpl)
    dpl.add_argument("remote"); dpl.add_argument("local")
    dps = d.add_parser("push", help="push LOCAL REMOTE")
    _serial_arg(dps)
    dps.add_argument("local"); dps.add_argument("remote")
    dbt = d.add_parser("battery", help="battery level")
    _serial_arg(dbt)

    p = sub.add_parser("build", help="Gradle builds")
    b = p.add_subparsers(dest="action", required=True)
    ba = b.add_parser("apk", help="assemble variant")
    ba.add_argument("--dir", help="project dir (default cwd)")
    ba.add_argument("--variant", default="debug", choices=["debug", "release"])
    bt = b.add_parser("test", help="run unit tests")
    bt.add_argument("--dir")
    bc = b.add_parser("clean", help="gradle clean")
    bc.add_argument("--dir")
    bta = b.add_parser("tasks", help="list gradle tasks (saved to file)")
    bta.add_argument("--dir")
    bi = b.add_parser("info", help="project build info")
    bi.add_argument("--dir")

    p = sub.add_parser("apk", help="APK inspection")
    k = p.add_subparsers(dest="action", required=True)
    for name, help_ in (("info", "package/version/sdk/perms summary"),
                        ("perms", "permissions detail"),
                        ("manifest", "AndroidManifest xmltree (saved to file)"),
                        ("sign", "verify + signing certs")):
        kp = k.add_parser(name, help=help_)
        kp.add_argument("apk")

    p = sub.add_parser("proj", help="project inspection")
    pp = p.add_subparsers(dest="action", required=True)
    p1 = pp.add_parser("info", help="modules/appId/sdk versions")
    p1.add_argument("--dir")

    p = sub.add_parser("studio", help="Android Studio IDE")
    u = p.add_subparsers(dest="action", required=True)
    uo = u.add_parser("open", help="open project in Android Studio")
    uo.add_argument("--dir")
    u.add_parser("status", help="installed/running?")

    args = ap.parse_args()
    if hasattr(args, "packages"):
        args.timeout = max(args.timeout, 900)  # sdk installs are slow
    sdk = _detect_sdk()
    jdk = _detect_jdk(sdk)
    g = args.group
    try:
        if g == "env":
            cmd_env(args, sdk, jdk, args.pretty)
        elif g == "sdk":
            cmd_sdk(args, sdk, jdk, args.pretty)
        elif g == "avd":
            cmd_avd(args, sdk, jdk, args.pretty)
        elif g == "dev":
            cmd_dev(args, sdk, jdk, args.pretty)
        elif g == "build":
            cmd_build(args, sdk, jdk, args.pretty)
        elif g == "apk":
            cmd_apk(args, sdk, jdk, args.pretty)
        elif g == "proj":
            cmd_proj(args, sdk, jdk, args.pretty)
        elif g == "studio":
            cmd_studio(args, sdk, jdk, args.pretty)
    except BrokenPipeError:
        pass

if __name__ == "__main__":
    main()