Upload folder using huggingface_hub

conftest.py

@@ -12,14 +12,8 @@ from appium import webdriver
 from utils import options, write_qdc_log
 
 
-@pytest.fixture(scope="session")
+@pytest.fixture(scope="session", autouse=True)
 def driver():
-    """Appium WebDriver fixture (only used by scorecard tests).
-
-    For most Linux tests, direct SSH commands are used instead.
-    This fixture is not auto-initialized to avoid connection errors
-    when the Appium server isn't needed.
-    """
     return webdriver.Remote(command_executor="http://127.0.0.1:4723/wd/hub", options=options)
 
 

requirements.txt

@@ -0,0 +1,22 @@
+Appium-Python-Client==5.2.4
+attrs==25.4.0
+certifi==2025.10.5
+exceptiongroup==1.3.0
+h11==0.16.0
+idna==3.11
+iniconfig==2.1.0
+outcome==1.3.0.post0
+packaging==25.0
+pluggy==1.6.0
+PySocks==1.7.1
+pytest==8.4.2
+selenium==4.36.0
+sniffio==1.3.1
+sortedcontainers==2.4.0
+tomli==2.3.0
+trio==0.31.0
+trio-websocket==0.12.2
+typing_extensions==4.15.0
+urllib3==2.5.0
+websocket-client==1.9.0
+wsproto==1.2.0

run_backend_ops_posix.py

@@ -0,0 +1,45 @@
+# ---------------------------------------------------------------------
+# Copyright (c) 2025 Qualcomm Technologies, Inc. and/or its subsidiaries.
+# SPDX-License-Identifier: BSD-3-Clause
+# ---------------------------------------------------------------------
+"""
+On-device test-backend-ops runner for llama.cpp (HTP0 backend).
+
+Executed by QDC's Appium test framework on the QDC runner.
+The runner has ADB access to the allocated device.
+"""
+
+import os
+import sys
+
+import pytest
+
+from utils import BIN_PATH, CMD_PREFIX, push_bundle_if_needed, run_adb_command, write_qdc_log
+
+
+@pytest.fixture(scope="session", autouse=True)
+def install(driver):
+    push_bundle_if_needed(f"{BIN_PATH}/test-backend-ops")
+
+
+@pytest.mark.parametrize("type_a", ["mxfp4", "fp16", "q4_0"])
+def test_backend_ops_htp0(type_a):
+    cmd = f"{CMD_PREFIX} GGML_HEXAGON_HOSTBUF=0 GGML_HEXAGON_EXPERIMENTAL=1 {BIN_PATH}/test-backend-ops -b HTP0 -o MUL_MAT"
+    if type_a == "q4_0":
+        cmd += r' -p "^(?=.*type_a=q4_0)(?!.*type_b=f32,m=576,n=512,k=576).*$"'
+    else:
+        cmd += f" -p type_a={type_a}"
+    result = run_adb_command(
+        cmd,
+        check=False,
+    )
+    write_qdc_log(f"backend_ops_{type_a}.log", result.stdout or "")
+    assert result.returncode == 0, f"test-backend-ops type_a={type_a} failed (exit {result.returncode})"
+
+
+if __name__ == "__main__":
+    ret = pytest.main(["-s", "--junitxml=results.xml", os.path.realpath(__file__)])
+    if os.path.exists("results.xml"):
+        with open("results.xml") as f:
+            write_qdc_log("results.xml", f.read())
+    sys.exit(ret)

run_bench_tests_posix.py

@@ -0,0 +1,80 @@
+# ---------------------------------------------------------------------
+# Copyright (c) 2025 Qualcomm Technologies, Inc. and/or its subsidiaries.
+# SPDX-License-Identifier: BSD-3-Clause
+# ---------------------------------------------------------------------
+"""
+On-device bench and completion test runner for llama.cpp (CPU, GPU, NPU backends).
+
+Executed by QDC's Appium test framework on the QDC runner.
+The runner has ADB access to the allocated device.
+
+Placeholders replaced at artifact creation time by run_qdc_jobs.py:
+  <<MODEL_URL>>  Direct URL to the GGUF model file (downloaded on-device via curl)
+"""
+
+import os
+import subprocess
+import sys
+
+import pytest
+
+from utils import BIN_PATH, CMD_PREFIX, push_bundle_if_needed, run_adb_command, write_qdc_log
+
+MODEL_PATH = "/data/local/tmp/model.gguf"
+PROMPT     = "What is the capital of France?"
+CLI_OPTS   = "--batch-size 128 -n 128 -no-cnv --seed 42"
+
+
+@pytest.fixture(scope="session", autouse=True)
+def install(driver):
+    push_bundle_if_needed(f"{BIN_PATH}/llama-cli")
+
+    # Skip model download if already present
+    check = subprocess.run(
+        ["adb", "shell", f"ls {MODEL_PATH}"],
+        text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+    )
+    if check.returncode != 0:
+        run_adb_command(f'curl -L -J --output {MODEL_PATH} "<<MODEL_URL>>"')
+
+
+@pytest.mark.parametrize("device,extra_flags", [
+    pytest.param("none",      "-ctk q8_0 -ctv q8_0", id="cpu"),
+    pytest.param("GPUOpenCL", "",                     id="gpu"),
+    pytest.param("HTP0",      "-ctk q8_0 -ctv q8_0", id="npu"),
+])
+def test_llama_completion(device, extra_flags):
+    result = run_adb_command(
+        f'{CMD_PREFIX} {BIN_PATH}/llama-completion'
+        f' -m {MODEL_PATH} --device {device} -ngl 99 -t 4 {CLI_OPTS} {extra_flags} -fa on'
+        f' -p "{PROMPT}"',
+        check=False,
+    )
+    write_qdc_log(f"llama_completion_{device}.log", result.stdout or "")
+    assert result.returncode == 0, f"llama-completion {device} failed (exit {result.returncode})"
+
+
+_DEVICE_LOG_NAME = {"none": "cpu", "GPUOpenCL": "gpu", "HTP0": "htp"}
+
+
+@pytest.mark.parametrize("device", [
+    pytest.param("none",      id="cpu"),
+    pytest.param("GPUOpenCL", id="gpu"),
+    pytest.param("HTP0",      id="npu"),
+])
+def test_llama_bench(device):
+    result = run_adb_command(
+        f"{CMD_PREFIX} {BIN_PATH}/llama-bench"
+        f" -m {MODEL_PATH} --device {device} -ngl 99 --batch-size 128 -t 4 -p 128 -n 32",
+        check=False,
+    )
+    write_qdc_log(f"llama_bench_{_DEVICE_LOG_NAME[device]}.log", result.stdout or "")
+    assert result.returncode == 0, f"llama-bench {device} failed (exit {result.returncode})"
+
+
+if __name__ == "__main__":
+    ret = pytest.main(["-s", "--junitxml=results.xml", os.path.realpath(__file__)])
+    if os.path.exists("results.xml"):
+        with open("results.xml") as f:
+            write_qdc_log("results.xml", f.read())
+    sys.exit(ret)

run_scorecard_posix.py

@@ -0,0 +1,237 @@
+# ---------------------------------------------------------------------
+# Copyright (c) 2025 Qualcomm Technologies, Inc. and/or its subsidiaries.
+# SPDX-License-Identifier: BSD-3-Clause
+# ---------------------------------------------------------------------
+"""
+Scorecard benchmark script for llama.cpp on Android devices via Appium.
+
+This script runs comprehensive benchmarks using the run-*.sh scripts from
+llama.cpp/scripts/snapdragon/adb/:
+  1. Performance benchmarks (CPU/GPU/HTP x 3 context lengths)
+  2. Fallback ops detection (SCHED=1)
+  3. Perplexity (WikiText-2)
+
+Placeholders are replaced at artifact creation time:
+  - <<MODEL_URL>>: URL to download the model
+"""
+
+import os
+import subprocess
+import sys
+
+import pytest
+from appium import webdriver
+from appium.options.common import AppiumOptions
+
+options = AppiumOptions()
+options.set_capability("automationName", "UiAutomator2")
+options.set_capability("platformName", "Android")
+options.set_capability("deviceName", os.getenv("ANDROID_DEVICE_VERSION"))
+
+# Context lengths to benchmark
+CONTEXT_LENGTHS = [128, 1024, 4096]
+
+# System prompt for completion benchmarks
+SYSTEM_PROMPT = "You are a helpful assistant. Be helpful but brief."
+
+
+class TestScorecard:
+    @pytest.fixture
+    def driver(self) -> webdriver.Remote:
+        return webdriver.Remote(
+            command_executor="http://127.0.0.1:4723/wd/hub", options=options
+        )
+
+    def test_scorecard(self, driver: webdriver.Remote) -> None:
+        """Run comprehensive llama.cpp scorecard benchmarks."""
+        model_url = "<<MODEL_URL>>"
+        num_htps = "<<NUM_HTPS>>"
+
+        # On-device paths (matching llama.cpp scripts/snapdragon/adb conventions)
+        basedir = "/data/local/tmp/llama.cpp"
+        model_path = "/data/local/tmp/gguf/model.gguf"
+        log_file = "/data/local/tmp/QDC_logs/scorecard.log"
+
+        scorecard_script = f"""
+cd /data/local/tmp/llama_cpp_bundle
+
+export LD_LIBRARY_PATH=/data/local/tmp/llama_cpp_bundle/lib:$LD_LIBRARY_PATH
+export ADSP_LIBRARY_PATH="/data/local/tmp/llama_cpp_bundle/lib;/system/lib/rfsa/adsp;/system/vendor/lib/rfsa/adsp;/dsp"
+chmod +x /data/local/tmp/llama_cpp_bundle/bin/*
+
+BASEDIR=/data/local/tmp/llama_cpp_bundle
+MODEL={model_path}
+LOG_FILE={log_file}
+NUM_HTPS={num_htps}
+HTP_FLAGS="--no-mmap --poll 1000 -t 6 --cpu-mask 0xfc --cpu-strict 1 -fa on -ngl 99"
+
+mkdir -p /data/local/tmp/gguf /data/local/tmp/QDC_logs
+
+echo "Downloading model from {model_url}..."
+curl -L -J --output $MODEL "{model_url}"
+
+echo "============================================================" > $LOG_FILE
+echo "LLAMA.CPP SCORECARD" >> $LOG_FILE
+echo "Date: $(date)" >> $LOG_FILE
+echo "Model: {model_url}" >> $LOG_FILE
+echo "============================================================" >> $LOG_FILE
+
+# --- Helper: derive NDEV and extra flags from compute unit ---
+device_flags() {{
+    local DEVICE="$1"
+    NDEV=0; EXTRA_FLAGS=""
+    case "$DEVICE" in
+        CPU) EXTRA_FLAGS="--n-gpu-layers 0" ;;
+        GPU) EXTRA_FLAGS="-fa off" ;;
+        HTP) NDEV=$NUM_HTPS
+             EXTRA_FLAGS="$HTP_FLAGS --device HTP0 -ctk f16 -ctv f16 --batch-size 128" ;;
+    esac
+}}
+
+#############################################
+# SECTION 1: PERFORMANCE BENCHMARKS
+#############################################
+echo "" >> $LOG_FILE
+echo "########################################################" >> $LOG_FILE
+echo "# SECTION 1: PERFORMANCE BENCHMARKS" >> $LOG_FILE
+echo "########################################################" >> $LOG_FILE
+
+for COMPUTE in CPU GPU HTP; do
+    device_flags "$COMPUTE"
+    for CTX_LEN in 128 1024 4096; do
+        echo "" >> $LOG_FILE
+        echo "=== $COMPUTE | CTX=$CTX_LEN ===" >> $LOG_FILE
+        GGML_HEXAGON_NDEV=$NDEV $BASEDIR/bin/llama-completion \\
+            --model $MODEL \\
+            --n-predict -1 \\
+            --ctx-size $CTX_LEN \\
+            --system-prompt "{SYSTEM_PROMPT}" \\
+            --file "$BASEDIR/sample_prompt_${{CTX_LEN}}.txt" \\
+            --seed 1 --single-turn --no-display-prompt \\
+            $EXTRA_FLAGS \\
+            2>&1 | tee -a $LOG_FILE
+    done
+done
+
+#############################################
+# SECTION 2: FALLBACK OPS DETECTION
+#############################################
+echo "" >> $LOG_FILE
+echo "########################################################" >> $LOG_FILE
+echo "# SECTION 2: FALLBACK OPS (GGML_SCHED_DEBUG=2)" >> $LOG_FILE
+echo "########################################################" >> $LOG_FILE
+
+for DEVICE in GPU HTP; do
+    device_flags "$DEVICE"
+    echo "" >> $LOG_FILE
+    echo "=== FALLBACK_OPS | $DEVICE ===" >> $LOG_FILE
+    GGML_SCHED_DEBUG=2 GGML_HEXAGON_NDEV=$NDEV $BASEDIR/bin/llama-completion \\
+        --model $MODEL \\
+        --n-predict 256 --ctx-size 128 \\
+        -p "Hello world" \\
+        --seed 1 --single-turn --no-display-prompt \\
+        $EXTRA_FLAGS -v \\
+        2>&1 | tee -a $LOG_FILE
+done
+
+#############################################
+# SECTION 3: PERPLEXITY (WikiText-2)
+#############################################
+echo "" >> $LOG_FILE
+echo "########################################################" >> $LOG_FILE
+echo "# SECTION 3: PERPLEXITY (WikiText-2)" >> $LOG_FILE
+echo "########################################################" >> $LOG_FILE
+
+for DEVICE in CPU GPU HTP; do
+    device_flags "$DEVICE"
+    echo "" >> $LOG_FILE
+    echo "=== PERPLEXITY | $DEVICE ===" >> $LOG_FILE
+    GGML_HEXAGON_NDEV=$NDEV $BASEDIR/bin/llama-perplexity \\
+        -m $MODEL \\
+        -f $BASEDIR/wiki.test.raw \\
+        --ctx-size 2048 --chunks 10 \\
+        $EXTRA_FLAGS \\
+        2>&1 | tee -a $LOG_FILE
+done
+
+#############################################
+# SECTION 4: QUALITY CHECKS (Q&A Validation)
+#############################################
+echo "" >> $LOG_FILE
+echo "########################################################" >> $LOG_FILE
+echo "# SECTION 4: QUALITY CHECKS" >> $LOG_FILE
+echo "########################################################" >> $LOG_FILE
+
+run_quality_check() {{
+    local DEVICE="$1" QUESTION="$2" EXPECTED="$3"
+    device_flags "$DEVICE"
+
+    echo "" >> $LOG_FILE
+    echo "--- Quality Check ($DEVICE) ---" >> $LOG_FILE
+    echo "Question: $QUESTION" >> $LOG_FILE
+    echo "Expected to contain: $EXPECTED" >> $LOG_FILE
+
+    RAW_RESPONSE=$(GGML_HEXAGON_NDEV=$NDEV $BASEDIR/bin/llama-completion \\
+        --model $MODEL \\
+        -p "$QUESTION" \\
+        --n-predict 256 --ctx-size 512 \\
+        --seed 1 --single-turn --no-display-prompt \\
+        $EXTRA_FLAGS \\
+        2>/dev/null)
+
+    RESPONSE=$(echo "$RAW_RESPONSE" | sed 's/[^[:print:][:space:]]//g' | sed '/^[[:space:]]*$/d' | head -20)
+
+    echo "RESPONSE_START" >> $LOG_FILE
+    echo "$RESPONSE" >> $LOG_FILE
+    echo "RESPONSE_END" >> $LOG_FILE
+
+    if echo "$RAW_RESPONSE" | grep -qi "$EXPECTED"; then
+        echo "QUALITY_CHECK: $DEVICE | $QUESTION | $EXPECTED | PASS" >> $LOG_FILE
+    else
+        echo "QUALITY_CHECK: $DEVICE | $QUESTION | $EXPECTED | FAIL" >> $LOG_FILE
+    fi
+}}
+
+for DEVICE in CPU GPU HTP; do
+    echo "" >> $LOG_FILE
+    echo "=== QUALITY_CHECKS | $DEVICE ===" >> $LOG_FILE
+    run_quality_check "$DEVICE" "The capital of France is" "Paris"
+    run_quality_check "$DEVICE" "2 + 2 =" "4"
+    run_quality_check "$DEVICE" "The planet closest to the Sun is" "Mercury"
+done
+
+echo "" >> $LOG_FILE
+echo "============================================================" >> $LOG_FILE
+echo "=== SCORECARD COMPLETE ===" >> $LOG_FILE
+echo "============================================================" >> $LOG_FILE
+"""
+
+        # Push the bundle to the device
+        subprocess.run(
+            ["adb", "push", "/qdc/appium/llama_cpp_bundle/", "/data/local/tmp"],
+            capture_output=True,
+            encoding="utf-8",
+            errors="replace",
+            check=True,
+        )
+
+        # Run the scorecard script
+        result = subprocess.run(
+            [
+                "adb",
+                "shell",
+                "sh",
+                "-c",
+                scorecard_script,
+            ],
+            capture_output=True,
+            encoding="utf-8",
+            errors="replace",
+            check=True,
+        )
+        print(result.stdout)
+        print(result.stderr)
+
+
+if __name__ == "__main__":
+    sys.exit(pytest.main(["-s", "--junitxml=results.xml", os.path.realpath(__file__)]))

utils.py

@@ -2,12 +2,7 @@
 # Copyright (c) 2025 Qualcomm Technologies, Inc. and/or its subsidiaries.
 # SPDX-License-Identifier: BSD-3-Clause
 # ---------------------------------------------------------------------
-"""Shared helpers for QDC on-device test runners (Linux/IoT devices).
-
-Unlike Android devices which use ADB, Linux IoT devices are accessed via
-SSH through QDC's infrastructure. The test scripts run directly on the
-device through the QDC Appium session.
-"""
+"""Shared helpers for QDC on-device test runners."""
 
 import os
 import subprocess
@@ -16,131 +11,42 @@ import tempfile
 from appium.options.common import AppiumOptions
 
 # ---------------------------------------------------------------------------
-# On-device paths (Linux IoT)
+# On-device paths
 # ---------------------------------------------------------------------------
 
-BUNDLE_PATH = "/tmp/llama_cpp_bundle"
-QDC_LOGS_PATH = "/tmp/QDC_logs"
-LIB_PATH = f"{BUNDLE_PATH}/lib"
-BIN_PATH = f"{BUNDLE_PATH}/bin"
-ENV_PREFIX = (
-    f"export LD_LIBRARY_PATH={LIB_PATH}:$LD_LIBRARY_PATH && "
+BUNDLE_PATH  = "/data/local/tmp/llama_cpp_bundle"
+QDC_LOGS_PATH = "/data/local/tmp/QDC_logs"
+LIB_PATH    = f"{BUNDLE_PATH}/lib"
+BIN_PATH    = f"{BUNDLE_PATH}/bin"
+ENV_PREFIX  = (
+    f"export LD_LIBRARY_PATH={LIB_PATH} && "
     f"export ADSP_LIBRARY_PATH={LIB_PATH} && "
     f"chmod +x {BIN_PATH}/* &&"
 )
-CMD_PREFIX = f"cd {BUNDLE_PATH} && {ENV_PREFIX}"
+CMD_PREFIX  = f"cd {BUNDLE_PATH} && {ENV_PREFIX}"
 
 # ---------------------------------------------------------------------------
-# Appium session options (Linux/IoT)
+# Appium session options
 # ---------------------------------------------------------------------------
 
 options = AppiumOptions()
-options.set_capability("automationName", "QDCLinux")
-options.set_capability("platformName", "Linux")
-options.set_capability("deviceName", os.getenv("QDC_DEVICE_NAME", "QCS9075M"))
+options.set_capability("automationName", "UiAutomator2")
+options.set_capability("platformName", "Android")
+options.set_capability("deviceName", os.getenv("ANDROID_DEVICE_VERSION"))
 
 # ---------------------------------------------------------------------------
-# SSH/Shell helpers for Linux devices
+# ADB helpers
 # ---------------------------------------------------------------------------
 
-
-def verify_binary_exists(binary_path: str) -> bool:
-    """Verify that a binary exists and is executable.
-
-    Args:
-        binary_path: Full path to the binary to check
-
-    Returns:
-        True if binary exists and is executable, False otherwise
-    """
-    print(f"[DEBUG] Verifying binary: {binary_path}")
-
-    # Check if file exists
-    result = run_shell_command(f"test -f {binary_path}", check=False)
-    if result.returncode != 0:
-        print(f"[ERROR] Binary does not exist: {binary_path}")
-        print(f"[ERROR] Expected location: {binary_path}")
-        print(f"[ERROR] Bundle should be at: {BUNDLE_PATH}")
-        print(f"[ERROR] Check if binaries were pushed correctly")
-        return False
-
-    # Check if executable
-    result = run_shell_command(f"test -x {binary_path}", check=False)
-    if result.returncode != 0:
-        print(f"[WARNING] Binary exists but is not executable: {binary_path}")
-        print(f"[DEBUG] Attempting to set executable permissions")
-        chmod_result = run_shell_command(f"chmod +x {binary_path}", check=False)
-        if chmod_result.returncode != 0:
-            print(f"[ERROR] Failed to set executable permissions on {binary_path}")
-            return False
-        print(f"[DEBUG] Successfully set executable permissions")
-
-    # Get file info for debugging
-    ls_result = run_shell_command(f"ls -lh {binary_path}", check=False)
-    if ls_result.returncode == 0:
-        print(f"[DEBUG] Binary info: {ls_result.stdout.strip()}")
-
-    print(f"[DEBUG] Binary verified: {binary_path}")
-    return True
-
-
-def run_shell_command(cmd: str, *, check: bool = True) -> subprocess.CompletedProcess:
-    """Run a shell command on the Linux device.
-
-    For QDC Linux devices, commands are executed through the QDC infrastructure
-    which provides SSH access to the device. The QDC Appium driver handles the
-    SSH tunneling transparently.
-
-    When running directly on-device (QDC_DEVICE_HOST=localhost), executes
-    commands locally via shell to avoid SSH password prompts.
-    """
-    device_host = os.getenv("QDC_DEVICE_HOST", "localhost")
-
-    print(f"[DEBUG] Running command on device_host='{device_host}'")
-    print(f"[DEBUG] Command: {cmd[:200]}{'...' if len(cmd) > 200 else ''}")
-
-    try:
-        # If localhost, run directly via shell (avoids SSH password prompt for on-device testing)
-        if device_host == "localhost":
-            raw = subprocess.run(
-                ["/bin/sh", "-c", f"{cmd}; echo __RC__:$?"],
-                text=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                timeout=300,
-            )
-        else:
-            # Remote device: use SSH
-            print(f"[DEBUG] Using SSH to connect to {device_host}")
-            raw = subprocess.run(
-                ["ssh", "-o", "BatchMode=yes", "-o", "ConnectTimeout=10",
-                 device_host, f"{cmd}; echo __RC__:$?"],
-                text=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                timeout=300,
-            )
-
-            # Check for SSH authentication failures
-            if raw.returncode != 0 and raw.stdout:
-                if "Permission denied" in raw.stdout:
-                    print("[ERROR] SSH authentication failed! Password required or key not set up.")
-                    print("[ERROR] To fix: Set up passwordless SSH or set QDC_DEVICE_HOST=localhost if on-device")
-                elif "Connection refused" in raw.stdout:
-                    print(f"[ERROR] SSH connection refused to {device_host}. Is SSH server running?")
-                elif "Host key verification failed" in raw.stdout:
-                    print(f"[ERROR] SSH host key verification failed for {device_host}")
-                    print("[ERROR] To fix: ssh-keyscan {device_host} >> ~/.ssh/known_hosts")
-
-    except subprocess.TimeoutExpired as e:
-        print(f"[ERROR] Command timed out after 300 seconds")
-        print(f"[ERROR] Command was: {cmd[:200]}")
-        raise
-
+def run_adb_command(cmd: str, *, check: bool = True) -> subprocess.CompletedProcess:
+    # Append exit-code sentinel because `adb shell` doesn't reliably propagate
+    # the on-device exit code (older ADB versions always return 0).
+    raw = subprocess.run(
+        ["adb", "shell", f"{cmd}; echo __RC__:$?"],
+        text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+    )
     stdout = raw.stdout
     returncode = raw.returncode
-
-    # Parse exit code from __RC__: sentinel
     if stdout:
         lines = stdout.rstrip("\n").split("\n")
         if lines and lines[-1].startswith("__RC__:"):
@@ -148,155 +54,40 @@ def run_shell_command(cmd: str, *, check: bool = True) -> subprocess.CompletedPr
                 returncode = int(lines[-1][7:])
                 stdout = "\n".join(lines[:-1]) + "\n"
             except ValueError:
-                print(f"[WARNING] Failed to parse exit code from: {lines[-1]}")
-
+                pass
     print(stdout)
-
-    if returncode != 0:
-        print(f"[ERROR] Command failed with exit code {returncode}")
-
-        # Try to provide helpful context for common errors
-        if "No such file or directory" in stdout:
-            print("[ERROR] File or directory not found. Check if binaries were pushed to device.")
-            print(f"[ERROR] Expected bundle path: {BUNDLE_PATH}")
-        elif "Permission denied" in stdout and device_host == "localhost":
-            print("[ERROR] Permission denied. Check file permissions or run with appropriate privileges.")
-        elif "not found" in stdout.lower() or "command not found" in stdout.lower():
-            print("[ERROR] Command not found. Check if binary exists and is in PATH or use full path.")
-
     result = subprocess.CompletedProcess(raw.args, returncode, stdout=stdout)
     if check:
-        assert returncode == 0, f"Command failed (exit {returncode})\nCommand: {cmd[:200]}\nOutput: {stdout[:500]}"
+        assert returncode == 0, f"Command failed (exit {returncode})"
     return result
 
 
 def write_qdc_log(filename: str, content: str) -> None:
-    """Write content as a log file to QDC_LOGS_PATH on the device for QDC log collection."""
-    print(f"[DEBUG] Writing QDC log: {filename} ({len(content)} bytes)")
-
-    # Ensure log directory exists
-    mkdir_result = run_shell_command(f"mkdir -p {QDC_LOGS_PATH}", check=False)
-    if mkdir_result.returncode != 0:
-        print(f"[WARNING] Failed to create log directory {QDC_LOGS_PATH}: {mkdir_result.stdout}")
-
-    device_host = os.getenv("QDC_DEVICE_HOST", "localhost")
-
+    """Push content as a log file to QDC_LOGS_PATH on the device for QDC log collection."""
+    subprocess.run(
+        ["adb", "shell", f"mkdir -p {QDC_LOGS_PATH}"],
+        stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+    )
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".log", delete=False) as f:
+        f.write(content)
+        tmp_path = f.name
     try:
-        if device_host == "localhost":
-            # Running on-device: write directly to filesystem
-            log_path = f"{QDC_LOGS_PATH}/{filename}"
-            with open(log_path, "w") as f:
-                f.write(content)
-            print(f"[DEBUG] Successfully wrote log to {log_path}")
-        else:
-            # Remote device: use SCP
-            with tempfile.NamedTemporaryFile(mode="w", suffix=".log", delete=False) as f:
-                f.write(content)
-                tmp_path = f.name
-
-            print(f"[DEBUG] Using SCP to transfer log to {device_host}")
-            result = subprocess.run(
-                ["scp", "-o", "BatchMode=yes", "-o", "ConnectTimeout=10",
-                 tmp_path, f"{device_host}:{QDC_LOGS_PATH}/{filename}"],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                timeout=60,
-                text=True,
-            )
-
-            if result.returncode != 0:
-                print(f"[ERROR] SCP failed with exit code {result.returncode}")
-                print(f"[ERROR] Output: {result.stdout}")
-            else:
-                print(f"[DEBUG] Successfully transferred log to {device_host}:{QDC_LOGS_PATH}/{filename}")
-
-            os.unlink(tmp_path)
-
-    except Exception as e:
-        print(f"[ERROR] Failed to write QDC log {filename}: {e}")
-        raise
+        subprocess.run(
+            ["adb", "push", tmp_path, f"{QDC_LOGS_PATH}/{filename}"],
+            stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+        )
+    finally:
+        os.unlink(tmp_path)
 
 
 def push_bundle_if_needed(check_binary: str) -> None:
     """Push llama_cpp_bundle to the device if check_binary is not already present."""
-    print(f"[DEBUG] Checking if binary exists: {check_binary}")
-
-    result = run_shell_command(f"ls {check_binary}", check=False)
-
-    if result.returncode == 0:
-        print(f"[DEBUG] Binary already exists on device: {check_binary}")
-        return
-
-    print(f"[WARNING] Binary not found: {check_binary}")
-    print(f"[DEBUG] Will attempt to push bundle from /qdc/appium/llama_cpp_bundle/ to {BUNDLE_PATH}")
-
-    device_host = os.getenv("QDC_DEVICE_HOST", "localhost")
-    source_path = "/qdc/appium/llama_cpp_bundle/"
-
-    try:
-        if device_host == "localhost":
-            # Running on-device: copy locally (if source exists)
-            if not os.path.exists(source_path):
-                print(f"[ERROR] Source bundle not found at {source_path}")
-                print(f"[ERROR] You may need to manually copy binaries to {BUNDLE_PATH}")
-                print(f"[ERROR] Expected structure: {BUNDLE_PATH}/{{bin,lib}}/")
-                return
-
-            print(f"[DEBUG] Copying bundle from {source_path} to /tmp/")
-            result = subprocess.run(
-                ["cp", "-r", source_path, "/tmp/"],
-                text=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                timeout=120,
-            )
-
-            if result.returncode != 0:
-                print(f"[ERROR] Failed to copy bundle: {result.stdout}")
-            else:
-                print(f"[DEBUG] Successfully copied bundle to {BUNDLE_PATH}")
-
-                # Verify the copy succeeded
-                verify = run_shell_command(f"ls {check_binary}", check=False)
-                if verify.returncode != 0:
-                    print(f"[ERROR] Bundle copied but binary still not found: {check_binary}")
-                else:
-                    print(f"[DEBUG] Verified binary exists after copy: {check_binary}")
-        else:
-            # Remote device: use SCP
-            print(f"[DEBUG] Using SCP to transfer bundle to {device_host}:/tmp/")
-
-            if not os.path.exists(source_path):
-                print(f"[ERROR] Source bundle not found at {source_path}")
-                print(f"[ERROR] Cannot push to remote device")
-                return
-
-            result = subprocess.run(
-                ["scp", "-r", "-o", "BatchMode=yes", "-o", "ConnectTimeout=10",
-                 source_path, f"{device_host}:/tmp/"],
-                text=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                timeout=120,
-            )
-
-            if result.returncode != 0:
-                print(f"[ERROR] SCP failed: {result.stdout}")
-                if "Permission denied" in result.stdout:
-                    print("[ERROR] SSH authentication failed. Set up passwordless SSH.")
-            else:
-                print(f"[DEBUG] Successfully transferred bundle to {device_host}:{BUNDLE_PATH}")
-
-                # Verify the transfer succeeded
-                verify = run_shell_command(f"ls {check_binary}", check=False)
-                if verify.returncode != 0:
-                    print(f"[ERROR] Bundle transferred but binary still not found: {check_binary}")
-                else:
-                    print(f"[DEBUG] Verified binary exists after transfer: {check_binary}")
-
-    except subprocess.TimeoutExpired:
-        print(f"[ERROR] Timeout while pushing bundle (exceeded 120 seconds)")
-        raise
-    except Exception as e:
-        print(f"[ERROR] Unexpected error while pushing bundle: {e}")
-        raise
+    result = subprocess.run(
+        ["adb", "shell", f"ls {check_binary}"],
+        text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+    )
+    if result.returncode != 0:
+        subprocess.run(
+            ["adb", "push", "/qdc/appium/llama_cpp_bundle/", "/data/local/tmp"],
+            text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+        )