make.py

'''
This is the NCOS SDK tool used to created applications
for Cradlepoint NCOS devices. It will work on Linux,
OS X, and Windows once the computer environment is setup.

'''

import os
import sys
import uuid
import json
import shutil
import subprocess
import configparser
import unittest
import datetime
import hashlib
import re
import tarfile
import gzip
import time
import zipfile
import platform
import webbrowser
from urllib.parse import quote

try:
    import requests
    import urllib3
    urllib3.disable_warnings()
    from requests.auth import HTTPDigestAuth
except ImportError:
    requests = None
    HTTPDigestAuth = None
    
# Upgrade functionality for checking and updating files from GitHub
def get_github_commit_timestamp(file_path):
    """
    Get the timestamp of the last commit for a specific file in cradlepoint/sdk-samples.
    
    Args:
        file_path (str): Path to the file (e.g., 'app_template/cp.py')
    
    Returns:
        datetime: Timestamp of the last commit, or None if error
    """
    url = "https://api.github.com/repos/cradlepoint/sdk-samples/commits"
    params = {'path': file_path, 'per_page': 1}
    
    try:
        response = requests.get(url, params=params)
        response.raise_for_status()
        
        commit_data = response.json()[0]
        timestamp_str = commit_data['commit']['committer']['date']
        
        # Convert to datetime object (compatible with all Python versions)
        # GitHub returns ISO format like: 2024-01-15T10:30:45Z
        # Remove 'Z' and parse manually
        timestamp_str = timestamp_str.replace('Z', '')
        return datetime.datetime.strptime(timestamp_str, '%Y-%m-%dT%H:%M:%S')
        
    except (requests.exceptions.RequestException, KeyError, IndexError) as e:
        print(f"Error getting GitHub commit timestamp: {e}")
        return None

def get_local_file_timestamp(file_path):
    """
    Get the modification timestamp of a local file.
    
    Args:
        file_path (str): Path to the local file
    
    Returns:
        datetime: Timestamp of the file modification, or None if file doesn't exist
    """
    if not os.path.exists(file_path):
        return None
    
    timestamp = os.path.getmtime(file_path)
    return datetime.datetime.fromtimestamp(timestamp)

def download_file_from_github(file_path, output_path=None):
    """
    Download a file from cradlepoint/sdk-samples repository.
    
    Args:
        file_path (str): Path to the file in the repo (e.g., 'app_template/cp.py')
        output_path (str, optional): Local path to save the file
    
    Returns:
        bool: True if successful, False otherwise
    """
    # GitHub raw URL format
    raw_url = f"https://raw.githubusercontent.com/cradlepoint/sdk-samples/master/{file_path}"
    
    try:
        response = requests.get(raw_url)
        response.raise_for_status()
        
        # If no output path specified, use the original file path
        if output_path is None:
            output_path = file_path
        
        # Create directory if it doesn't exist (only if there's a directory path)
        dir_path = os.path.dirname(output_path)
        if dir_path:
            os.makedirs(dir_path, exist_ok=True)
        
        # Write the file
        with open(output_path, 'w', encoding='utf-8') as f:
            f.write(response.text)
        
        # Update file timestamp to current time to prevent repeated downloads
        import time
        current_time = time.time()
        os.utime(output_path, (current_time, current_time))
        
        print(f"File downloaded successfully to: {output_path}")
        return True
        
    except requests.exceptions.RequestException as e:
        print(f"Error downloading file: {e}")
        return False

def check_and_update_file(file_path, local_path=None):
    """
    Check if the GitHub version of a file is newer than the local version,
    and download if it is.
    
    Args:
        file_path (str): Path to the file in the repo (e.g., 'app_template/cp.py')
        local_path (str, optional): Local path to the file. If None, uses file_path
    
    Returns:
        dict: Status information about the check and update
    """
    if local_path is None:
        local_path = file_path
    
    print(f"Checking file: {file_path}")
    
    # Get GitHub commit timestamp
    github_timestamp = get_github_commit_timestamp(file_path)
    if github_timestamp is None:
        return {'status': 'error', 'message': 'Could not get GitHub timestamp'}
    
    # Get local file timestamp
    local_timestamp = get_local_file_timestamp(local_path)
    
    print(f"GitHub last commit: {github_timestamp.strftime('%Y-%m-%d %H:%M:%S UTC')}")
    
    if local_timestamp is None:
        print("Local file does not exist. Downloading...")
        success = download_file_from_github(file_path, local_path)
        return {
            'status': 'downloaded' if success else 'error',
            'message': 'File downloaded' if success else 'Download failed',
            'github_timestamp': github_timestamp,
            'local_timestamp': None
        }
    else:
        # Compare timestamps (GitHub timestamp is in UTC, local is in local timezone)
        # Convert local timestamp to UTC for proper comparison
        import time
        local_utc_offset = time.timezone if (time.daylight == 0) else time.altzone
        # time.timezone is negative for timezones behind UTC, so we add the absolute value to get UTC
        local_utc_timestamp = local_timestamp + datetime.timedelta(seconds=abs(local_utc_offset))
        print(f"Local file modified: {local_utc_timestamp.strftime('%Y-%m-%d %H:%M:%S UTC')}")
        
        if github_timestamp > local_utc_timestamp:
            print("GitHub version is newer. Downloading...")
            success = download_file_from_github(file_path, local_path)
            return {
                'status': 'updated' if success else 'error',
                'message': 'File updated' if success else 'Update failed',
                'github_timestamp': github_timestamp,
                'local_timestamp': local_timestamp
            }
        else:
            print("Local file is up to date.")
            return {
                'status': 'up_to_date',
                'message': 'Local file is current',
                'github_timestamp': github_timestamp,
                'local_timestamp': local_timestamp
            }

def update():
    """
    Check and update core files from the GitHub repository.
    Updates: make.py and apps/templates/app_template/cp.py
    """
    print("Checking for updates to core SDK files...")
    print("=" * 50)
    
    # Files to check and update
    files_to_check = [
        ("make.py", "make.py"),
        ("apps/templates/app_template/cp.py", "apps/templates/app_template/cp.py"),
    ]
    
    results = {}
    updated_count = 0
    error_count = 0
    
    for repo_path, local_path in files_to_check:
        print(f"\n--- {local_path} ---")
        result = check_and_update_file(repo_path, local_path)
        results[local_path] = result
        
        if result['status'] == 'updated':
            updated_count += 1
        elif result['status'] == 'downloaded':
            updated_count += 1
        elif result['status'] == 'error':
            error_count += 1
        
        print(f"Status: {result['status']}")
    
    # Summary
    print("\n" + "=" * 50)
    print("UPDATE SUMMARY")
    print("=" * 50)
    
    for file_path, result in results.items():
        status_icon = "✓" if result['status'] in ['updated', 'downloaded', 'up_to_date'] else "✗"
        print(f"{status_icon} {file_path}: {result['status']}")
    
    print(f"\nFiles updated: {updated_count}")
    print(f"Errors: {error_count}")
    print(f"Files up to date: {len(files_to_check) - updated_count - error_count}")
    
    if updated_count > 0:
        print(f"\n{updated_count} file(s) have been updated.")
    
    if error_count > 0:
        print(f"\n{error_count} file(s) had errors during the update process.")

# These will be set in init() by using the sdk_settings.ini file.
# They are used by various functions in the file.
g_app_name = ''
g_app_uuid = ''
# Set when the user passes a .tar.gz file instead of an app name. When set,
# install/deploy use this exact file rather than looking for a built package.
g_app_archive = ''
g_dev_client_ip = ''
g_dev_client_username = ''
g_dev_client_password = ''
g_python_cmd = 'python3'  # Default for Linux and OS X

# Seconds to wait on router HTTP requests. Without this, an unreachable or
# wrong IP in sdk_settings.ini hangs with no output.
REQUEST_TIMEOUT = 10

# Constants for packaging
META_DATA_FOLDER = 'METADATA'
CONFIG_FILE = 'package.ini'
SIGNATURE_FILE = 'SIGNATURE.DS'
MANIFEST_FILE = 'MANIFEST.json'

BYTE_CODE_FILES = re.compile(r'^.*/.(pyc|pyo|pyd)$')
BYTE_CODE_FOLDERS = re.compile('^(__pycache__)$')

DEFAULT_IGNORE = ['__pycache__/', 'buildignore', '.DS_Store']


def parse_ignore_file(app_root):
    """Parse .ignore file in app directory and return list of patterns to exclude.
    Combines default ignore patterns with any patterns from the .ignore file.

    Args:
        app_root (str): Path to the app directory

    Returns:
        tuple: (ignored_files, ignored_dirs) - sets of filenames and directory names to ignore
    """
    ignored_files = set()
    ignored_dirs = set()

    # Add default ignored directories
    for pattern in DEFAULT_IGNORE:
        if pattern.endswith('/'):
            ignored_dirs.add(pattern.rstrip('/'))
        else:
            ignored_files.add(pattern)

    # Parse .ignore file if it exists
    ignore_path = os.path.join(app_root, 'buildignore')
    if os.path.isfile(ignore_path):
        with open(ignore_path, 'r') as f:
            for line in f:
                line = line.strip()
                if not line or line.startswith('#'):
                    continue
                if line.endswith('/'):
                    ignored_dirs.add(line.rstrip('/'))
                else:
                    ignored_files.add(line)
        print('Loaded .ignore file with {} file(s) and {} dir(s) to exclude'.format(
            len(ignored_files), len(ignored_dirs)))

    return ignored_files, ignored_dirs


# Returns the proper HTTP Auth for the global username and password.
# Digest Auth is used for NCOS 6.4 and below while Basic Auth is
# used for NCOS 6.5 and up.
def get_auth():
    from http import HTTPStatus

    use_basic = False
    device_api = 'https://{}/api/status/product_info'.format(g_dev_client_ip)

    try:
        response = requests.get(device_api, auth=requests.auth.HTTPBasicAuth(g_dev_client_username, g_dev_client_password), verify=False, timeout=REQUEST_TIMEOUT)
        if response.status_code == HTTPStatus.OK:
            use_basic = True

    except:
        use_basic = False

    if use_basic:
        return requests.auth.HTTPBasicAuth(g_dev_client_username, g_dev_client_password)
    else:
        return requests.auth.HTTPDigestAuth(g_dev_client_username, g_dev_client_password)


# Returns boolean to indicate if the NCOS device is
# in DEV mode. Returns False and prints a message if
# the device is unreachable or not in dev mode.
def is_NCOS_device_in_DEV_mode():
    raw = get('/status/system/sdk/mode')
    if raw is None:
        print('\nERROR: Could not connect to NCOS device at {}.'.format(g_dev_client_ip))
        print('       Verify the device is powered on, reachable, and that')
        print('       sdk_settings.ini has the correct IP/credentials.')
        return False
    try:
        data = json.loads(raw)
    except (json.JSONDecodeError, TypeError):
        print('\nERROR: Unexpected response from NCOS device at {}.'.format(g_dev_client_ip))
        return False
    mode = data.get('data', '')
    if mode == 'devmode':
        return True
    elif mode == 'standard':
        print('\nERROR: NCOS device at {} is not in Developer Mode.'.format(g_dev_client_ip))
        print('       Enable Dev Mode in NetCloud Manager: Tools > Developer Mode Devices.')
        return False
    else:
        print('\nERROR: Unexpected SDK mode ({}) on device at {}.'.format(mode, g_dev_client_ip))
        return False


# Returns the app package name based on the global app name.
def get_app_pack(app_name=None):
    package_name = (app_name or g_app_name) + ".tar.gz"
    if app_name is not None:
        package_name = app_name + ".tar.gz"
    return package_name


# Where make.py looks for apps and packages, in priority order:
# '' is the repo root, then the apps/ folder.
APP_SEARCH_DIRS = ('', 'apps')


def _has_path_separator(name):
    return '/' in name or '\\' in name or os.sep in name


def _listdir(path):
    """os.listdir that returns an empty list instead of raising."""
    try:
        return sorted(os.listdir(path))
    except OSError:
        return []


def find_section(config, app_name):
    """Return the package.ini section matching app_name, ignoring case.

    Returns None when no section matches.
    """
    target = app_name.lower()
    for section in config.sections():
        if section.lower() == target:
            return section
    return None


def find_app_dir(app_name):
    """Locate an app directory by name, ignoring case.

    Searches the repo root first, then the apps/ folder. Directories that
    contain a package.ini are preferred over bare name matches. Returns the
    path relative to the current working directory, or None if not found.
    """
    if not app_name:
        return None

    app_name = app_name.rstrip('/\\')

    # An explicit path was given (e.g. apps/My_App) — honor it as-is.
    if _has_path_separator(app_name) and os.path.isdir(app_name):
        return app_name

    cwd = os.getcwd()
    target = os.path.basename(app_name).lower()
    candidates = []

    for base in APP_SEARCH_DIRS:
        base_path = os.path.join(cwd, base) if base else cwd
        if not os.path.isdir(base_path):
            continue
        for item in _listdir(base_path):
            if item.lower() != target:
                continue
            rel = os.path.join(base, item) if base else item
            if os.path.isdir(os.path.join(cwd, rel)):
                candidates.append(rel)

    # Prefer a match that actually looks like an app.
    for candidate in candidates:
        if os.path.isfile(os.path.join(candidate, CONFIG_FILE)):
            return candidate

    return candidates[0] if candidates else None


def find_file(file_name):
    """Locate a file by name in the repo root first, then apps/, ignoring case.

    Returns the path relative to the current working directory, or None.
    """
    if not file_name:
        return None

    # An explicit path was given — only honor it as-is.
    if _has_path_separator(file_name):
        return file_name if os.path.isfile(file_name) else None

    cwd = os.getcwd()
    target = file_name.lower()

    for base in APP_SEARCH_DIRS:
        base_path = os.path.join(cwd, base) if base else cwd
        if not os.path.isdir(base_path):
            continue
        for item in _listdir(base_path):
            if item.lower() != target:
                continue
            rel = os.path.join(base, item) if base else item
            if os.path.isfile(os.path.join(cwd, rel)):
                return rel

    return None


def is_archive_name(name):
    """True if name looks like an app package file (.tar.gz)."""
    return bool(name) and name.lower().endswith('.tar.gz')


def archive_to_app_name(archive):
    """Derive an app name from a package file name.

    'My_App v1.2.3.tar.gz'  -> 'My_App'
    'My_App_v1.2.3.tar.gz'  -> 'My_App'
    'my_app.tar.gz'         -> 'my_app'
    """
    name = os.path.basename(archive.rstrip('/\\'))
    name = re.sub(r'\.tar\.gz$', '', name, flags=re.IGNORECASE)
    # Strip a trailing version suffix, separated by a space, underscore or dash.
    name = re.sub(r'[\s_-]+v\d+(\.\d+)*$', '', name, flags=re.IGNORECASE)
    return name


def read_app_version(app_path, app_name=None):
    """Read 'major.minor.patch' from an app's package.ini.

    Returns None when package.ini or its section is missing.
    """
    app_name = app_name or os.path.basename(app_path)
    config_path = os.path.join(app_path, CONFIG_FILE)
    if not os.path.isfile(config_path):
        return None

    config = configparser.ConfigParser()
    try:
        config.read(config_path)
    except configparser.Error as err:
        print('WARNING: Could not read {}: {}'.format(config_path, err))
        return None

    section = find_section(config, app_name)
    if section is None:
        return None

    return '{}.{}.{}'.format(config[section].get('version_major', '0'),
                             config[section].get('version_minor', '0'),
                             config[section].get('version_patch', '0'))


def find_app_archive(app_name):
    """Locate the .tar.gz package to install, ignoring case.

    If app_name is itself a .tar.gz file, that exact file is used. Otherwise
    the app directory is located (repo root first, then apps/), the version is
    read from its package.ini, and the matching package file is searched for in
    the repo root first, then apps/.

    Returns the path relative to the current working directory, or None.
    """
    if not app_name:
        return None

    # A package file was named directly — use that exact file.
    if is_archive_name(app_name):
        return find_file(app_name)

    app_path = find_app_dir(app_name)
    # Use the on-disk folder name so the package file name matches what
    # build produced, even if the user typed a different case.
    actual_name = os.path.basename(app_path) if app_path else app_name

    wanted = []
    if app_path:
        version = read_app_version(app_path, actual_name)
        if version:
            wanted.append('{} v{}.tar.gz'.format(actual_name, version))
    wanted.append('{}.tar.gz'.format(actual_name))

    for name in wanted:
        match = find_file(name)
        if match:
            return match

    # Fall back to any package file starting with the app name. Reverse sort so
    # the highest version wins when several builds are lying around.
    cwd = os.getcwd()
    prefix = actual_name.lower()
    for base in APP_SEARCH_DIRS:
        base_path = os.path.join(cwd, base) if base else cwd
        if not os.path.isdir(base_path):
            continue
        for item in sorted(_listdir(base_path), reverse=True):
            lowered = item.lower()
            if not lowered.startswith(prefix) or not lowered.endswith('.tar.gz'):
                continue
            rel = os.path.join(base, item) if base else item
            if os.path.isfile(os.path.join(cwd, rel)):
                return rel

    return None


# Gets data from the NCOS config store
def get(config_tree):
    if requests is None:
        print("Error: 'requests' library is not installed. Run: pip install requests")
        return None

    ncos_api = 'https://{}/api{}'.format(g_dev_client_ip, config_tree)

    try:
        response = requests.get(ncos_api, auth=get_auth(), verify=False, timeout=REQUEST_TIMEOUT)

    except (requests.exceptions.Timeout,
            requests.exceptions.ConnectionError) as ex:
        print("Error with get for NCOS device at {}. Exception: {}".format(g_dev_client_ip, ex))
        return None

    try:
        return json.dumps(json.loads(response.text), indent=4)
    except (json.JSONDecodeError, TypeError):
        # Non-JSON reply (e.g. an auth error page) — treat as unreachable.
        print("Error: unexpected reply from NCOS device at {} (HTTP {}).".format(
            g_dev_client_ip, response.status_code))
        return None


# Get a list of all the apps in the directory
def get_app_list():
    app_dirs = []
    cwd = os.getcwd()
    print("Scanning {} for app directories.".format(cwd))

    # Search under apps/ directory for package.ini files (flat structure)
    apps_dir = os.path.join(cwd, 'apps')
    if os.path.isdir(apps_dir):
        for item in os.listdir(apps_dir):
            if item in ('templates', 'archive', '__pycache__', 'METADATA', '.git', '.venv'):
                continue
            item_path = os.path.join(apps_dir, item)
            if os.path.isdir(item_path) and os.path.isfile(os.path.join(item_path, 'package.ini')):
                app_dirs.append(item_path)
    else:
        # Fallback: look in cwd for flat structure (backward compat)
        dirs_in_cwd = os.listdir(cwd)
        for item in dirs_in_cwd:
            if os.path.isdir(item):
                contents = os.listdir(item)
                if 'package.ini' in contents:
                    app_dirs.append(item)

    # Also check repo root for apps in active development (created but not yet moved)
    dirs_in_cwd = os.listdir(cwd)
    for item in dirs_in_cwd:
        item_path = os.path.join(cwd, item)
        if os.path.isdir(item_path) and item not in ['apps', 'archive', 'docs', '.git', '.github', '.kiro', '.venv', '__pycache__']:
            if os.path.isfile(os.path.join(item_path, 'package.ini')):
                if item_path not in app_dirs:
                    app_dirs.append(item_path)

    # Warn about duplicate app names
    names_seen = {}
    for app_dir in app_dirs:
        name = os.path.basename(app_dir)
        if name in names_seen:
            print("WARNING: Duplicate app name '{}' found at:\n  {}\n  {}".format(
                name, names_seen[name], app_dir))
        else:
            names_seen[name] = app_dir

    return app_dirs


# Puts an SDK action in the NCOS device config store
def put(value):
    try:
        response = requests.put("https://{}/api/control/system/sdk/action".format(g_dev_client_ip),
                                headers={"Content-Type": "application/x-www-form-urlencoded"},
                                auth=get_auth(),
                                data={"data": '"{} {}"'.format(value, get_app_uuid())},
                                verify=False, timeout=REQUEST_TIMEOUT)

    except (requests.exceptions.Timeout,
            requests.exceptions.ConnectionError) as ex:
        print("Error with put for NCOS device at {}. Exception: {}".format(g_dev_client_ip, ex))
        return None

    try:
        return json.dumps(json.loads(response.text), indent=4)
    except (json.JSONDecodeError, TypeError):
        print("Error: unexpected reply from NCOS device at {} (HTTP {}).".format(
            g_dev_client_ip, response.status_code))
        return None


# Cleans the SDK directory for a given app by removing files created during packaging.
def clean(app=None):
    app_name = app or g_app_name
    print("Cleaning {}".format(app_name))
    app_pack_name = app_name + ".tar.gz"
    try:
        files_to_clean = [app_name + ".tar.gz", app_name + ".tar"]
        for file_name in files_to_clean:
            if os.path.isfile(file_name):
                os.remove(file_name)
                print('Deleted file: {}'.format(file_name))
    except OSError as e:
        print('Clean Error 1 for file {}: {}'.format(app_pack_name, e))

    # Apps live in apps/ but older ones may still be at the repo root, so
    # resolve the real directory instead of assuming either location.
    app_dir = find_app_dir(app_name) or app_name
    meta_dir = os.path.join(os.getcwd(), app_dir, META_DATA_FOLDER)
    try:
        if os.path.isdir(meta_dir):
            shutil.rmtree(meta_dir)
    except OSError as e:
        print('Clean Error 2 for directory {}: {}'.format(meta_dir, e))

    build_file = os.path.join(os.getcwd(), '.build')
    try:
        if os.path.isfile(build_file):
            os.remove(build_file)
    except OSError as e:
        print('Clean Error 3 for file {}: {}'.format(build_file, e))


# Cleans the SDK directory for all apps by removing files created during packaging.
def clean_all():
    cwd = os.getcwd()
    print("Scanning {} for app directories.".format(cwd))
    app_dirs = get_app_list()

    for app in app_dirs:
        clean(app)


def scan_for_cr(path):
    scanfiles = ('.py', '.sh')
    for root, _, files in os.walk(path):
        for fl in files:
            # Only process files with the specified extensions
            if any(fl.endswith(ext) for ext in scanfiles):
                file_path = os.path.join(root, fl)
                with open(file_path, 'rb') as f:
                    content = f.read()
                if b'\r' in content:
                    # Remove carriage returns and write back to the file
                    new_content = content.replace(b'\r', b'')
                    with open(file_path, 'wb') as f:
                        f.write(new_content)
                    print(f'Removed carriage return (\\r) from file {file_path}')


def file_checksum(hash_func=hashlib.sha256, file=None):
    h = hash_func()
    buffer_size = h.block_size * 64

    with open(file, 'rb') as f:
        for buffer in iter(lambda: f.read(buffer_size), b''):
            h.update(buffer)
    return h.hexdigest()


def hash_dir(target, hash_func=hashlib.sha256, ignored_files=None, ignored_dirs=None):
    if ignored_files is None or ignored_dirs is None:
        ignored_files, ignored_dirs = parse_ignore_file(target)
    hashed_files = {}
    for path, d, f in os.walk(target):
        # Prune ignored directories in-place so os.walk won't descend into them
        d[:] = [x for x in d if x not in ignored_dirs]
        for fl in f:
            if fl in ignored_files:
                print("Ignored file: {}".format(fl))
                continue
            if not fl.startswith('.') and not os.path.basename(path).startswith('.'):
                # we need this be LINUX fashion!
                if sys.platform == "win32":
                    # swap the network\\tcp_echo to be network/tcp_echo
                    fully_qualified_file = path.replace('\\', '/') + '/' + fl
                else:  # else allow normal method
                    fully_qualified_file = os.path.join(path, fl)
                hashed_files[fully_qualified_file[len(target) + 1:]] =\
                    file_checksum(hash_func, fully_qualified_file)
            else:
                print("Did not include {} in the App package.".format(fl))

    return hashed_files


def pack_package(app_root, app_name, ignored_files=None, ignored_dirs=None):
    if ignored_files is None or ignored_dirs is None:
        ignored_files, ignored_dirs = parse_ignore_file(app_root)

    def tar_filter(tarinfo):
        basename = os.path.basename(tarinfo.name)
        if tarinfo.isdir() and basename in ignored_dirs:
            return None
        if tarinfo.isfile() and basename in ignored_files:
            return None
        # Windows reports dirs as mode 555 (no write bit), breaking extraction
        # on NCM. Normalise mode/ownership so packages are OS-independent.
        tarinfo.mode = 0o755 if tarinfo.isdir() else 0o644
        tarinfo.uid = 0
        tarinfo.gid = 0
        tarinfo.uname = ''
        tarinfo.gname = ''
        return tarinfo

    tar_name = f"{app_name}.tar"
    with tarfile.open(tar_name, 'w') as tar:
        tar.add(app_root, arcname=os.path.basename(app_root), filter=tar_filter)

    gzip_name = "{}.tar.gz".format(app_name)
    with open(tar_name, 'rb') as f_in:
        with gzip.open(gzip_name, 'wb') as f_out:
            shutil.copyfileobj(f_in, f_out)

    if os.path.isfile(tar_name):
        os.remove(tar_name)


def create_signature(meta_data_folder, pkey):
    manifest_file = os.path.join(meta_data_folder, MANIFEST_FILE)
    with open(os.path.join(meta_data_folder, SIGNATURE_FILE), 'wb') as sf:
        checksum = file_checksum(hashlib.sha256, manifest_file).encode('utf-8')
        if pkey:
            try:
                from cryptography.hazmat.primitives import hashes, serialization
                from cryptography.hazmat.primitives.asymmetric import padding
                with open(pkey, 'rb') as kf:
                    private_key = serialization.load_pem_private_key(kf.read(), password=None)
                signature = private_key.sign(checksum, padding.PKCS1v15(), hashes.SHA256())
                sf.write(signature)
            except ImportError:
                print("WARNING: 'cryptography' library not installed. Writing unsigned checksum.")
                sf.write(checksum)
        else:
            sf.write(checksum)


def verify_manifest_signature(app_metadata_folder, pkey):
    """Recompute the SHA-256 checksum of MANIFEST.json and confirm it matches
    what is stored in SIGNATURE.DS (or that the signature verifies against
    the key, if the manifest was signed).

    Returns True if the signature is valid, False otherwise.
    """
    manifest_file = os.path.join(app_metadata_folder, MANIFEST_FILE)
    signature_file = os.path.join(app_metadata_folder, SIGNATURE_FILE)

    if not os.path.isfile(manifest_file) or not os.path.isfile(signature_file):
        print('ERROR: MANIFEST.json or SIGNATURE.DS is missing from {}'.format(app_metadata_folder))
        return False

    checksum = file_checksum(hashlib.sha256, manifest_file).encode('utf-8')

    with open(signature_file, 'rb') as sf:
        signature_data = sf.read()

    if pkey:
        try:
            from cryptography.hazmat.primitives import hashes, serialization
            from cryptography.hazmat.primitives.asymmetric import padding
            with open(pkey, 'rb') as kf:
                private_key = serialization.load_pem_private_key(kf.read(), password=None)
            public_key = private_key.public_key()
            public_key.verify(signature_data, checksum, padding.PKCS1v15(), hashes.SHA256())
            return True
        except ImportError:
            # 'cryptography' wasn't available when the signature was created,
            # so it was written as a plain checksum instead.
            return signature_data == checksum
        except Exception as err:
            print('ERROR: SIGNATURE.DS does not verify against MANIFEST.json: {}'.format(err))
            return False
    else:
        if signature_data != checksum:
            print('ERROR: SIGNATURE.DS checksum does not match MANIFEST.json contents.')
            return False
        return True


def verify_manifest_files(app_root, app_manifest_file, ignored_files=None, ignored_dirs=None):
    """Recompute checksums for every packaged file and compare them against
    the 'files' entry recorded in MANIFEST.json. Catches stale/corrupted
    METADATA content that would otherwise be packaged as-is and rejected by
    NCM on upload.

    Returns True if every recorded hash matches the file on disk, False
    otherwise.
    """
    try:
        with open(app_manifest_file, 'r') as f:
            manifest_data = json.load(f)
    except (OSError, json.JSONDecodeError) as err:
        print('ERROR: Could not read MANIFEST.json for verification: {}'.format(err))
        return False

    recorded_files = manifest_data.get('app', {}).get('files', {})

    if ignored_files is None or ignored_dirs is None:
        ignored_files, ignored_dirs = parse_ignore_file(app_root)

    # MANIFEST.json is written after files are hashed, so the METADATA
    # folder itself must be excluded to match what was originally hashed.
    verify_ignored_dirs = set(ignored_dirs) | {META_DATA_FOLDER}
    current_files = hash_dir(app_root, ignored_files=ignored_files, ignored_dirs=verify_ignored_dirs)

    if recorded_files == current_files:
        return True

    missing = sorted(set(recorded_files) - set(current_files))
    extra = sorted(set(current_files) - set(recorded_files))
    changed = sorted(
        fl for fl in (set(recorded_files) & set(current_files))
        if recorded_files[fl] != current_files[fl]
    )
    if missing:
        print('ERROR: Files listed in MANIFEST.json are missing from the app: {}'.format(missing))
    if extra:
        print('ERROR: Files in the app are not listed in MANIFEST.json: {}'.format(extra))
    if changed:
        print('ERROR: File checksums no longer match MANIFEST.json: {}'.format(changed))
    return False


def clean_manifest_folder(app_metadata_folder):
    path, dirs, files = next(os.walk(app_metadata_folder))

    for file in files:
        fully_qualified_file = os.path.join(path, file)
        os.remove(fully_qualified_file)

    for d in dirs:
        shutil.rmtree(os.path.join(path, d))


def clean_bytecode_files(app_root):
    for path, dirs, files in os.walk(app_root):
        for file in filter(lambda x: BYTE_CODE_FILES.match(x), files):
            os.remove(os.path.join(path, file))
        for d in filter(lambda x: BYTE_CODE_FOLDERS.match(x), dirs):
            shutil.rmtree(os.path.join(path, d))
    pass


def package_application(app_root, pkey):
    app_root = os.path.realpath(app_root)
    app_config_file = os.path.join(app_root, CONFIG_FILE)
    app_metadata_folder = os.path.join(app_root, META_DATA_FOLDER)
    app_manifest_file = os.path.join(app_metadata_folder, MANIFEST_FILE)
    config = configparser.ConfigParser()
    config.read(app_config_file)
    if not os.path.exists(app_metadata_folder):
        os.makedirs(app_metadata_folder)

    def build_manifest_and_signature(section):
        """Build MANIFEST.json and SIGNATURE.DS for the given package.ini
        section. Returns the 'app' dict that was written to the manifest."""
        clean_manifest_folder(app_metadata_folder)

        clean_bytecode_files(app_root)

        pmf = {}
        pmf['version_major'] = int(1)
        pmf['version_minor'] = int(0)
        pmf['version_patch'] = int(0)

        app = {}
        app['name'] = os.path.basename(app_root)
        try:
            app['uuid'] = config[section]['uuid']
        except KeyError:
            if not pkey:
                app['uuid'] = str(uuid.uuid4())
            else:
                raise
        app['vendor'] = config[section]['vendor']
        app['notes'] = config[section]['notes']
        app['version_major'] = int(config[section].get('version_major', '0'))
        app['version_minor'] = int(config[section].get('version_minor', '0'))
        app['version_patch'] = int(config[section].get('version_patch', '0'))
        app['firmware_major'] = int(config[section].get('firmware_major', '0'))
        app['firmware_minor'] = int(config[section].get('firmware_minor', '0'))
        app['restart'] = config[section].getboolean('restart')
        app['reboot'] = config[section].getboolean('reboot')
        app['date'] = datetime.datetime.now().isoformat()
        if config.has_option(section, 'auto_start'):
            app['auto_start'] = config[section].getboolean('auto_start')
        if config.has_option(section, 'app_type'):
            app['app_type'] = int(config[section]['app_type'])

        data = {}
        data['pmf'] = pmf
        data['app'] = app

        ignored_files, ignored_dirs = parse_ignore_file(app_root)
        app['files'] = hash_dir(app_root, ignored_files=ignored_files, ignored_dirs=ignored_dirs)

        with open(app_manifest_file, 'w') as f:
            f.write(json.dumps(data, indent=4, sort_keys=True))

        create_signature(app_metadata_folder, pkey)

        return app, ignored_files, ignored_dirs

    for section in config.sections():
        app_name = section
        # Case-insensitive match between folder name and section name
        if os.path.basename(app_root).lower() != app_name.lower():
            continue

        app, ignored_files, ignored_dirs = build_manifest_and_signature(section)

        # Verify the signature and file hashes we just wrote actually match
        # the manifest and the files on disk. A stale/corrupted METADATA
        # folder produces a package NCM will reject on upload, so rebuild
        # once from scratch before giving up.
        verified = (verify_manifest_signature(app_metadata_folder, pkey)
                    and verify_manifest_files(app_root, app_manifest_file, ignored_files, ignored_dirs))

        if not verified:
            print('WARNING: MANIFEST/SIGNATURE verification failed for {}. '
                  'Rebuilding METADATA from scratch...'.format(os.path.basename(app_root)))
            app, ignored_files, ignored_dirs = build_manifest_and_signature(section)
            verified = (verify_manifest_signature(app_metadata_folder, pkey)
                        and verify_manifest_files(app_root, app_manifest_file, ignored_files, ignored_dirs))

        if not verified:
            print('ERROR: Could not produce a valid MANIFEST.json/SIGNATURE.DS for {}. '
                  'Package was NOT created.'.format(os.path.basename(app_root)))
            return False

        app_name_version = f"{os.path.basename(app_root)} v{app['version_major']}.{app['version_minor']}.{app['version_patch']}"
        pack_package(app_root, app_name_version, ignored_files=ignored_files, ignored_dirs=ignored_dirs)

        print(f'Package {app_name_version}.tar.gz created')
        print('MANIFEST.json and SIGNATURE.DS verified.')
        return True

    return False


# Package the app files into a tar.gz archive.
def package(app=None):
    app_name = app or g_app_name

    # Find the app case-insensitively: repo root first, then apps/
    app_path = find_app_dir(app_name)
    if app_path is None:
        print("ERROR: App directory '{}' was not found in the repo root or "
              "apps/. Skipping.".format(app_name))
        return False

    # The app_name for packaging must match the folder basename
    actual_app_name = os.path.basename(app_path)

    # Verify the app has a valid package.ini with the correct section
    app_config_file = os.path.join(app_path, CONFIG_FILE)
    if not os.path.isfile(app_config_file):
        print("ERROR: '{}' not found in '{}'. Skipping.".format(CONFIG_FILE, app_path))
        return False

    config = configparser.ConfigParser()
    config.read(app_config_file)
    # Case-insensitive section lookup: find section matching folder name
    matched_section = find_section(config, actual_app_name)
    if matched_section is None:
        print("ERROR: The '{}' section does not exist in {}. Skipping.".format(actual_app_name, app_config_file))
        return False

    print("Packaging {}".format(actual_app_name))
    scan_for_cr(app_path)
    setup_script(app_path)

    try:
        return package_application(app_path, None)
    except Exception as err:
        print('Error packaging {}: {}'.format(actual_app_name, err))
        return False


# Package all the app files in the directory into a tar.gz archives.
def package_all():
    success = True
    cwd = os.getcwd()
    print("Scanning {} for app directories.".format(cwd))
    app_dirs = get_app_list()

    for app in app_dirs:
        if not package(app):
            success = False

    return success


def setup_script(app_path):
    # check app_path for setup.py and execute it
    setup_path = os.path.join(app_path, 'setup.py')
    if os.path.isfile(setup_path):
        cwd = os.getcwd()
        os.chdir(app_path)
        print('Running setup.py for {}'.format(app_path))
        try:
            out = subprocess.check_output('{} {}'.format(g_python_cmd, 'setup.py'), stderr=subprocess.STDOUT, shell=True).decode()
        except subprocess.CalledProcessError as e:
            print ('[ERROR]: Exit code != 0')
            out = e.output.decode()
        print(out)
        os.chdir(cwd)


# Get the SDK status from the NCOS device
def status():
    status_tree = '/status/system/sdk'
    print('Get {} status for NCOS device at {}'.format(status_tree, g_dev_client_ip))
    response = get(status_tree)
    print(response)

# Create new app from app_template using supplied app name
def create(app_name=None):
    if not app_name:
        print('ERROR: No app name provided. Please provide a name. If you are using Cursor AI, it will generate a name for you based on your requested functionality.')
        return

    # Create in apps/ — the same place the repo keeps its apps and where the
    # CI checks look. Every make.py command finds apps by name, so the path
    # only matters when you open the folder yourself.
    target_dir = os.path.join('apps', app_name)
    display_dir = 'apps/{}'.format(app_name)

    if os.path.exists(target_dir):
        print(f'App already exists at ./{display_dir}/. Please choose a different name.')
        return

    # An app created before apps/ became the default may still be at the repo root.
    if os.path.isdir(app_name) and os.path.isfile(os.path.join(app_name, 'package.ini')):
        print(f'App already exists at ./{app_name}/. Please choose a different name.')
        return

    # Find app_template
    template_path = os.path.join('apps', 'templates', 'app_template')
    if not os.path.isdir(template_path):
        # Fallback to old location
        template_path = 'app_template'
    if not os.path.isdir(template_path):
        print('ERROR: app_template not found.')
        return

    try:
        shutil.copytree(template_path, target_dir)
        os.rename(f'{target_dir}/app_template.py', f'{target_dir}/{app_name}.py')

        # Replace app_template with new app name in all files
        files = [f'{app_name}.py', 'package.ini', 'readme.md', 'start.sh']
        for file in files:
            path = f'{target_dir}/{file}'
            if os.path.isfile(path):
                with open(path, 'r') as in_file:
                    filedata = in_file.read()
                filedata = filedata.replace('app_template', app_name)
                with open(path, 'w') as out_file:
                    out_file.write(filedata)
        print(f'App {app_name} created at ./{display_dir}/')
    except Exception as e:
        print(f'Error creating app: {e}')

# Transfer the app tar.gz package to the NCOS device
def install():
    if is_NCOS_device_in_DEV_mode():
        # A .tar.gz passed on the command line is used exactly as given.
        # Otherwise find the app (repo root first, then apps/) case-insensitively
        # and locate the package file built from it.
        requested = g_app_archive or g_app_name
        app_archive = find_app_archive(requested)

        if not app_archive:
            if is_archive_name(requested):
                print('ERROR: Package file not found: {}'.format(requested))
            else:
                print('ERROR: No package file found for \'{}\' in the repo root '
                      'or apps/.'.format(requested))
                print('       Build it first: {} make.py build {}'.format(
                    g_python_cmd, requested))
            return 1

        print('Installing {} to {}...'.format(app_archive, g_dev_client_ip))

        import paramiko
        ssh = paramiko.SSHClient()
        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        try:
            ssh.connect(g_dev_client_ip, username=g_dev_client_username,
                        password=g_dev_client_password,
                        look_for_keys=False, allow_agent=False, timeout=10)
            transport = ssh.get_transport()

            # Legacy SCP protocol — remote path MUST be /app_upload (no trailing slash)
            channel = transport.open_session()
            channel.exec_command('scp -t /app_upload')

            # Wait for ready signal
            response = channel.recv(1)
            if response != b'\x00':
                err = channel.recv(1024).decode(errors='replace') if channel.recv_ready() else ''
                print('ERROR: SCP not ready: {}'.format(err))
                return 1

            # Send file header
            file_size = os.path.getsize(app_archive)
            filename = os.path.basename(app_archive)
            header = 'C0644 {} {}\n'.format(file_size, filename)
            channel.sendall(header.encode())

            # Wait for header ack
            response = channel.recv(1)
            if response != b'\x00':
                err = channel.recv(1024).decode(errors='replace') if channel.recv_ready() else ''
                print('ERROR: SCP rejected file: {}'.format(err))
                return 1

            # Send file content
            with open(app_archive, 'rb') as f:
                while True:
                    data = f.read(32768)
                    if not data:
                        break
                    channel.sendall(data)

            # Send completion signal
            channel.sendall(b'\x00')
            channel.close()
        except (EOFError, OSError, paramiko.ssh_exception.SSHException):
            # Router drops connection after receiving file — expected
            pass
        except Exception as e:
            print('ERROR: Upload failed: {}'.format(e))
            return 1
        finally:
            ssh.close()

        return 0
    else:
        print('ERROR: NCOS device is not in DEV Mode! Unable to install the app into {}.'.format(g_dev_client_ip))
        return 1


# Start the app in the NCOS device
def start():
    if is_NCOS_device_in_DEV_mode():
        print('Start application {} for NCOS device at {}'.format(g_app_name, g_dev_client_ip))
        print('Application UUID is {}.'.format(g_app_uuid))
        response = put('start')
        print(response)
    else:
        print('ERROR: NCOS device is not in DEV Mode! Unable to start the app from {}.'.format(g_dev_client_ip))


# Stop the app in the NCOS device
def stop():
    if is_NCOS_device_in_DEV_mode():
        print('Stop application {} for NCOS device at {}'.format(g_app_name, g_dev_client_ip))
        print('Application UUID is {}.'.format(g_app_uuid))
        response = put('stop')
        print(response)
    else:
        print('ERROR: NCOS device is not in DEV Mode! Unable to stop the app from {}.'.format(g_dev_client_ip))


# Uninstall the app from the NCOS device
def uninstall():
    if is_NCOS_device_in_DEV_mode():
        print('Uninstall application {} for NCOS device at {}'.format(g_app_name, g_dev_client_ip))
        print('Application UUID is {}.'.format(g_app_uuid))
        response = put('uninstall')
        print(response)
    else:
        print('ERROR: NCOS device is not in DEV Mode! Unable to uninstall the app from {}.'.format(g_dev_client_ip))


# Purge the app from the NCOS device
def purge():
    if is_NCOS_device_in_DEV_mode():
        result = put('purge')
        if result:
            try:
                data = json.loads(result)
                if data.get('success'):
                    print('Purge successful on {}.'.format(g_dev_client_ip))
                    return
            except (json.JSONDecodeError, TypeError):
                pass
            print('Purge failed on {}.'.format(g_dev_client_ip))
        else:
            print('Purge failed on {}.'.format(g_dev_client_ip))
    else:
        print('ERROR: NCOS device is not in DEV Mode! Unable to purge the app from {}.'.format(g_dev_client_ip))

def deploy():
    """Full deploy: purge, build, install, and show recent logs."""
    deploy_start = time.time()
    print('Purging apps from {}...'.format(g_dev_client_ip))
    purge()
    time.sleep(3)

    if g_app_archive:
        # A package file was named directly — install it as-is, no build.
        print('Using package file {}'.format(g_app_archive))
    elif not package():
        print('ERROR: Packaging failed.')
        return

    result = install()
    if result != 0:
        print('ERROR: Install failed.')
        return

    # Wait for the app to start, then show all recent logs
    time.sleep(8)
    try:
        log_url = 'https://{}/api/status/log/'.format(g_dev_client_ip)
        response = requests.get(log_url, auth=get_auth(), verify=False)
        logs = json.loads(response.text).get('data', [])
        # Anchor the cutoff to when this deploy started (not to "now"), so
        # slow purge/build/install steps can't push the app's own startup
        # log lines outside the window. A few seconds of slack cover clock
        # drift between this machine and the router.
        cutoff = deploy_start - 3
        recent = [e for e in logs if e[0] >= cutoff]
        if recent:
            print('Logs:')
            for entry in recent:
                ts = datetime.datetime.fromtimestamp(entry[0]).strftime('%H:%M:%S')
                facility = entry[2] if len(entry) > 2 else ''
                msg = entry[3] if len(entry) > 3 and entry[3] else ''
                print('  {} [{}] {}'.format(ts, facility, msg))
        else:
            print('  No log entries since deploy started.')
    except Exception as e:
        print('Warning: Could not fetch logs: {}'.format(e))

def setup():
    """Create .venv and install requirements.txt."""
    setup_script = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'setup_env.py')
    subprocess.run([sys.executable, setup_script], check=True)


# ---------------------------------------------------------------------------
# contribute: fork, branch, commit, push, and open a pull request for one app.
#
# The clone is expected to point at the canonical repo, so `git pull` always
# tracks upstream. The fork is created on demand and added as a *second*
# remote, which leaves `origin` alone.
# ---------------------------------------------------------------------------

UPSTREAM_REPO = 'cradlepoint/sdk-samples'
UPSTREAM_URL = 'https://github.com/{}.git'.format(UPSTREAM_REPO)
GH_VENDOR_DIR = '.gh'
GH_RELEASE_API = 'https://api.github.com/repos/cli/cli/releases/latest'

# Packaging leftovers that should never be copied or committed.
CONTRIB_IGNORE = shutil.ignore_patterns(
    META_DATA_FOLDER, '__pycache__', '*.pyc', '*.pyo', '*.pyd',
    '*.tar.gz', '*.tar', '.DS_Store')


def _run(cmd):
    """Run a command and capture its output. Returns (returncode, output)."""
    try:
        proc = subprocess.run(cmd, stdout=subprocess.PIPE,
                              stderr=subprocess.STDOUT, universal_newlines=True)
        return proc.returncode, (proc.stdout or '').strip()
    except Exception as e:
        return 1, str(e)


def _run_stream(cmd):
    """Run a command with its output (and input) attached to the terminal."""
    try:
        return subprocess.run(cmd).returncode
    except Exception as e:
        print('Error running {}: {}'.format(cmd[0], e))
        return 1


def _ask(question, default=''):
    """Prompt for a line of text. Returns default when the user just hits Enter."""
    prompt = '{} [{}]: '.format(question, default) if default else '{}: '.format(question)
    try:
        answer = input(prompt).strip()
    except EOFError:
        return default
    return answer or default


def _confirm(question, default=False):
    """Prompt for yes/no. Returns default on a bare Enter or no terminal."""
    suffix = '[Y/n]' if default else '[y/N]'
    try:
        answer = input('{} {} '.format(question, suffix)).strip().lower()
    except EOFError:
        return default
    if not answer:
        return default
    return answer in ('y', 'yes')


def _gh_vendor_exe():
    """Path where a downloaded gh binary is kept."""
    exe = 'gh.exe' if sys.platform.startswith('win') else 'gh'
    return os.path.join(GH_VENDOR_DIR, 'bin', exe)


def _find_gh():
    """Return a path to a usable gh, or None if it is not present."""
    on_path = shutil.which('gh')
    if on_path:
        return on_path
    vendored = _gh_vendor_exe()
    if os.path.isfile(vendored):
        return vendored
    return None


def _gh_asset_name(version):
    """Release asset name for this OS and CPU, or None if unsupported."""
    machine = platform.machine().lower()
    arch = 'arm64' if machine in ('arm64', 'aarch64') else 'amd64'
    if sys.platform.startswith('win'):
        return 'gh_{}_windows_{}.zip'.format(version, arch)
    if sys.platform == 'darwin':
        return 'gh_{}_macOS_{}.zip'.format(version, arch)
    if sys.platform.startswith('linux'):
        return 'gh_{}_linux_{}.tar.gz'.format(version, arch)
    return None


def _safe_members(archive_names):
    """True when no archive entry tries to escape the extraction directory."""
    for name in archive_names:
        if os.path.isabs(name) or name.startswith('/') or '..' in name.replace('\\', '/').split('/'):
            return False
    return True


def _extract_gh(archive_path, dest_dir):
    """Pull the gh binary out of a release archive. Returns its path or None."""
    tmp_dir = os.path.join(dest_dir, '_extract')
    shutil.rmtree(tmp_dir, ignore_errors=True)
    os.makedirs(tmp_dir, exist_ok=True)
    try:
        if archive_path.lower().endswith('.zip'):
            with zipfile.ZipFile(archive_path) as zf:
                if not _safe_members(zf.namelist()):
                    print('Refusing to extract: the archive contains unsafe paths.')
                    return None
                zf.extractall(tmp_dir)
        else:
            with tarfile.open(archive_path) as tf:
                if not _safe_members(tf.getnames()):
                    print('Refusing to extract: the archive contains unsafe paths.')
                    return None
                tf.extractall(tmp_dir)

        exe = 'gh.exe' if sys.platform.startswith('win') else 'gh'
        for root, _dirs, files in os.walk(tmp_dir):
            if exe in files and os.path.basename(root) == 'bin':
                bin_dir = os.path.join(dest_dir, 'bin')
                os.makedirs(bin_dir, exist_ok=True)
                target = os.path.join(bin_dir, exe)
                shutil.copy2(os.path.join(root, exe), target)
                os.chmod(target, 0o755)
                return target
        print('Could not find the gh binary inside the downloaded archive.')
        return None
    except Exception as e:
        print('Error unpacking the GitHub CLI: {}'.format(e))
        return None
    finally:
        shutil.rmtree(tmp_dir, ignore_errors=True)


def _download_gh():
    """Download the GitHub CLI into .gh/. Returns the binary path or None."""
    if requests is None:
        print("Error: the 'requests' library is needed to download the GitHub CLI.")
        print('Run "{} setup_env.py" first, or install gh yourself: https://cli.github.com'.format(g_python_cmd))
        return None

    print('Looking up the latest GitHub CLI release...')
    try:
        resp = requests.get(GH_RELEASE_API, timeout=30)
        resp.raise_for_status()
        release = resp.json()
    except Exception as e:
        print('Could not reach the GitHub releases API: {}'.format(e))
        return None

    version = str(release.get('tag_name') or '').lstrip('v')
    if not version:
        print('The releases API did not report a version.')
        return None

    asset_name = _gh_asset_name(version)
    if not asset_name:
        print('No GitHub CLI build is available for this platform ({}).'.format(sys.platform))
        print('Install it manually instead: https://cli.github.com')
        return None

    url = None
    for asset in release.get('assets') or []:
        if asset.get('name') == asset_name:
            url = asset.get('browser_download_url')
            break
    if not url:
        print('Could not find {} in the latest release.'.format(asset_name))
        return None

    os.makedirs(GH_VENDOR_DIR, exist_ok=True)
    archive_path = os.path.join(GH_VENDOR_DIR, asset_name)
    print('Downloading {}...'.format(asset_name))
    try:
        with requests.get(url, timeout=180, stream=True) as stream:
            stream.raise_for_status()
            with open(archive_path, 'wb') as out_file:
                for chunk in stream.iter_content(chunk_size=65536):
                    if chunk:
                        out_file.write(chunk)
    except Exception as e:
        print('Download failed: {}'.format(e))
        return None

    gh_path = _extract_gh(archive_path, GH_VENDOR_DIR)
    try:
        os.remove(archive_path)
    except OSError:
        pass

    if gh_path:
        print('GitHub CLI {} ready at ./{}'.format(version, gh_path.replace('\\', '/')))
    return gh_path


def _ensure_gh():
    """Find gh, offering to download it. Returns a path or None."""
    gh = _find_gh()
    if gh:
        return gh

    print('')
    print('The GitHub CLI (gh) is not installed. It handles the fork, the push')
    print('credentials, and the pull request in one step.')
    if not _confirm('Download it into ./{}/ (about 10 MB, no admin needed)?'.format(GH_VENDOR_DIR)):
        return None
    return _download_gh()


def _ensure_gh_auth(gh):
    """Make sure gh is logged in. Returns True when authenticated."""
    code, _ = _run([gh, 'auth', 'status'])
    if code == 0:
        return True

    print('')
    print('You need to sign in to GitHub once on this machine.')
    print('gh will show a one-time code and open your browser.')
    if not _confirm('Sign in now?', default=True):
        return False

    # Streamed, not captured: the user has to read the code and answer prompts.
    _run_stream([gh, 'auth', 'login', '--hostname', 'github.com',
                 '--git-protocol', 'https', '--web'])
    code, _ = _run([gh, 'auth', 'status'])
    return code == 0


def _remote_url(name):
    """URL for a git remote, or None if the remote does not exist."""
    code, out = _run(['git', 'remote', 'get-url', name])
    return out if code == 0 and out else None


def _is_upstream_url(url):
    return bool(url) and UPSTREAM_REPO in url.lower()


def _repo_owner(url):
    """GitHub account name from a remote URL, or None."""
    if not url:
        return None
    url = url.strip()
    if url.endswith('.git'):
        url = url[:-4]
    if url.startswith('git@'):
        path = url.split(':', 1)[-1]
    elif 'github.com' in url:
        path = url.split('github.com', 1)[-1].lstrip('/:')
    else:
        return None
    parts = [part for part in path.split('/') if part]
    return parts[0] if parts else None


def _resolve_upstream_remote():
    """Return the remote name that points at the canonical repo, adding it if needed."""
    if _is_upstream_url(_remote_url('origin')):
        return 'origin'
    for name in ('upstream', 'canonical'):
        if _is_upstream_url(_remote_url(name)):
            return name
    print('No remote points at {}. Adding one named "upstream".'.format(UPSTREAM_REPO))
    code, out = _run(['git', 'remote', 'add', 'upstream', UPSTREAM_URL])
    if code != 0:
        print('Could not add the upstream remote: {}'.format(out))
        return None
    return 'upstream'


def _find_fork_remote(upstream_remote):
    """Return the name of a remote that is a fork, or None."""
    code, out = _run(['git', 'remote'])
    if code != 0:
        return None
    for name in out.split():
        if name == upstream_remote:
            continue
        if not _is_upstream_url(_remote_url(name)):
            return name
    return None


def _upstream_branch(upstream_remote):
    """Default branch on the canonical repo."""
    for branch in ('master', 'main'):
        code, _ = _run(['git', 'rev-parse', '--verify', '--quiet',
                        '{}/{}'.format(upstream_remote, branch)])
        if code == 0:
            return branch
    return 'master'


def _create_fork(gh, upstream_remote):
    """Create the user's fork and wire it up as a remote. Returns its name or None."""
    print('Creating your fork of {} (skipped if you already have one)...'.format(UPSTREAM_REPO))
    args = [gh, 'repo', 'fork', UPSTREAM_REPO, '--remote', '--remote-name', 'fork']
    if _run_stream(args) != 0:
        print('gh could not create or wire up the fork.')
        return None
    if _remote_url('fork'):
        return 'fork'
    return _find_fork_remote(upstream_remote)


def _fork_by_hand(upstream_remote):
    """Browser fallback: user forks on github.com, we add the remote."""
    fork_url = 'https://github.com/{}/fork'.format(UPSTREAM_REPO)
    print('')
    print('Open this page and click "Create fork":')
    print('  {}'.format(fork_url))
    if _confirm('Open it in your browser now?', default=True):
        try:
            webbrowser.open(fork_url)
        except Exception as e:
            print('Could not open a browser: {}'.format(e))
    username = _ask('Your GitHub username (blank to stop)')
    if not username:
        return None
    url = 'https://github.com/{}/sdk-samples.git'.format(username)
    code, out = _run(['git', 'remote', 'add', 'fork', url])
    if code != 0:
        print('Could not add the fork remote: {}'.format(out))
        return None
    print('Added remote "fork" -> {}'.format(url))
    return 'fork'


def _check_contribution(app_dir):
    """Mirror the repo's CI checks. Returns a list of problem descriptions."""
    problems = []
    names = [name.lower() for name in _listdir(app_dir)]
    if 'readme.md' not in names and 'readme.txt' not in names:
        problems.append('No readme. Add {}/readme.md describing what the app does.'.format(app_dir))

    ini_path = os.path.join(app_dir, CONFIG_FILE)
    folder = os.path.basename(app_dir.rstrip('/\\'))
    if not os.path.isfile(ini_path):
        problems.append('No {} in {}.'.format(CONFIG_FILE, app_dir))
    else:
        try:
            with open(ini_path, 'r') as ini_file:
                body = ini_file.read()
            if '[{}]'.format(folder) not in body:
                problems.append('{} has no [{}] section matching the folder name.'.format(ini_path, folder))
        except Exception as e:
            problems.append('Could not read {}: {}'.format(ini_path, e))
    return problems


def contribute(app_name=None):
    """Fork, branch, commit, push, and open a pull request for one app."""
    if not app_name:
        print('ERROR: No app name provided. Example: make.py contribute my_app')
        return

    code, _ = _run(['git', 'rev-parse', '--git-dir'])
    if code != 0:
        print('ERROR: this folder is not a git repository.')
        print('Contributing needs a clone. If you downloaded a ZIP, clone instead:')
        print('  git clone {}'.format(UPSTREAM_URL))
        return

    if not shutil.which('git'):
        print('ERROR: git is not installed or not on PATH.')
        return

    app_dir = find_app_dir(app_name)
    if not app_dir:
        print('ERROR: could not find an app named "{}".'.format(app_name))
        return
    app_name = os.path.basename(app_dir.rstrip('/\\'))

    # Contributed apps live in apps/. Older apps at the repo root get copied
    # there, leaving the original alone so nothing disappears on a checkout.
    parent = os.path.dirname(app_dir).replace('\\', '/')
    if parent != 'apps':
        dest = os.path.join('apps', app_name)
        print('')
        print('./{} is at the repo root. Contributed apps live in apps/.'.format(app_dir))
        if os.path.exists(dest):
            print('ERROR: {} already exists. Sort that out first.'.format(dest))
            return
        if not _confirm('Copy it to {}/ for the pull request? Your original stays put.'.format(dest.replace('\\', '/'))):
            print('Nothing changed.')
            return
        try:
            shutil.copytree(app_dir, dest, ignore=CONTRIB_IGNORE)
        except Exception as e:
            print('Could not copy the app: {}'.format(e))
            return
        print('Copied to {}/'.format(dest.replace('\\', '/')))
        app_dir = dest

    app_dir = app_dir.replace('\\', '/')

    print('')
    print('Contributing ./{}/ to {}.'.format(app_dir, UPSTREAM_REPO))

    # Drop packaging leftovers before anything gets staged.
    clean(app_name)

    problems = _check_contribution(app_dir)
    if problems:
        print('')
        print('This app is not ready to contribute yet. CI checks the same things:')
        for problem in problems:
            print('  - {}'.format(problem))
        return

    upstream_remote = _resolve_upstream_remote()
    if not upstream_remote:
        return

    # Everything local first — branch and commit — so nothing touches your
    # GitHub account until you have seen and approved the commit.
    print('')
    print('Fetching {}...'.format(upstream_remote))
    if _run_stream(['git', 'fetch', upstream_remote]) != 0:
        print('Could not fetch {}.'.format(upstream_remote))
        return

    base = _upstream_branch(upstream_remote)
    branch = 'add-{}'.format(re.sub(r'[^A-Za-z0-9._-]', '-', app_name))

    code, staged = _run(['git', 'diff', '--cached', '--name-only'])
    if code == 0 and staged:
        print('')
        print('Note: you have staged changes elsewhere. Only {}/ will be committed.'.format(app_dir))

    code, current = _run(['git', 'rev-parse', '--abbrev-ref', 'HEAD'])
    if code == 0 and current == branch:
        print('Already on branch {}.'.format(branch))
    else:
        code, _ = _run(['git', 'rev-parse', '--verify', '--quiet', 'refs/heads/' + branch])
        if code == 0:
            if not _confirm('Branch {} already exists. Switch to it and add to it?'.format(branch), default=True):
                print('Nothing changed.')
                return
            switch = ['git', 'checkout', branch]
        else:
            switch = ['git', 'checkout', '-b', branch,
                      '{}/{}'.format(upstream_remote, base)]
        if _run_stream(switch) != 0:
            print('')
            print('Could not switch branches. Commit or stash your other changes first.')
            return

    code, to_add = _run(['git', 'add', '--dry-run', '--', app_dir])
    if code != 0:
        print('git could not stage {}: {}'.format(app_dir, to_add))
        return
    if not to_add:
        print('')
        print('Nothing to commit for {}/ — it already matches {}.'.format(app_dir, base))
        print('If you already pushed this app, open the pull request on GitHub.')
        return

    lines = to_add.splitlines()
    print('')
    print('These {} file(s) will be committed:'.format(len(lines)))
    for line in lines[:40]:
        print('  {}'.format(line.strip()))
    if len(lines) > 40:
        print('  ... and {} more'.format(len(lines) - 40))
    print('')
    print('Build artifacts, METADATA/, and sdk_settings.ini are git-ignored and excluded.')
    if not _confirm('Stage and commit these?', default=True):
        print('Nothing changed.')
        return

    if _run_stream(['git', 'add', '--', app_dir]) != 0:
        print('Could not stage {}.'.format(app_dir))
        return

    default_message = 'Add {} SDK sample app'.format(app_name)
    message = _ask('Commit message', default_message)
    if _run_stream(['git', 'commit', '-m', message, '--', app_dir]) != 0:
        print('Commit failed.')
        return

    # Committed locally. Now the GitHub side: fork, push, pull request.
    gh = _ensure_gh()
    if gh and not _ensure_gh_auth(gh):
        print('Not signed in to GitHub, falling back to the browser.')
        gh = None

    fork_remote = _find_fork_remote(upstream_remote)
    if not fork_remote:
        fork_remote = _create_fork(gh, upstream_remote) if gh else _fork_by_hand(upstream_remote)
    if not fork_remote:
        print('')
        print('No fork remote, so there is nowhere to push.')
        print('Your commit is safe on branch {}. Add a fork remote and push when ready:'.format(branch))
        print('  git remote add fork https://github.com/YOUR-USERNAME/sdk-samples.git')
        print('  git push -u fork {}'.format(branch))
        return

    fork_owner = _repo_owner(_remote_url(fork_remote))
    if not fork_owner:
        print('Could not work out the GitHub account behind remote "{}".'.format(fork_remote))
        return

    print('')
    print('Pulling from "{}", pushing to "{}" ({}).'.format(
        upstream_remote, fork_remote, fork_owner))
    print('Pushing {} to "{}"...'.format(branch, fork_remote))
    if _run_stream(['git', 'push', '-u', fork_remote, branch]) != 0:
        print('')
        print('Push failed. The usual cause is missing GitHub credentials for git.')
        if gh:
            print('Try "{} auth setup-git" and run contribute again.'.format(gh))
        else:
            print('On macOS, git asks for a password here and it must be a personal')
            print('access token, not your GitHub password. Installing the GitHub CLI')
            print('avoids this entirely: https://cli.github.com')
        return

    title = _ask('Pull request title', message)
    body = _ask('Short description for the pull request (optional)') or title

    if gh:
        print('')
        print('Opening the pull request...')
        pr_cmd = [gh, 'pr', 'create', '--repo', UPSTREAM_REPO,
                  '--base', base, '--head', '{}:{}'.format(fork_owner, branch),
                  '--title', title, '--body', body]
        if _run_stream(pr_cmd) == 0:
            print('')
            print('Done. Your app is up for review.')
            return
        print('gh could not create the pull request. Falling back to the browser.')

    compare_url = 'https://github.com/{}/compare/{}...{}:{}?expand=1&title={}&body={}'.format(
        UPSTREAM_REPO, base, fork_owner, branch, quote(title), quote(body))
    print('')
    print('Your branch is pushed. Open the pull request here:')
    print('  {}'.format(compare_url))
    if _confirm('Open it in your browser now?', default=True):
        try:
            webbrowser.open(compare_url)
        except Exception as e:
            print('Could not open a browser: {}'.format(e))




# Prints the help information
def output_help():
    print('Command format is: {} make.py <action>\n'.format(g_python_cmd))
    print('Actions include:')
    print('================')
    print('create: Create a new app from the app_template folder.')
    print('\tThe app is created in the apps/ folder and the path is printed when it is done.')
    print(f'\tYou must provide a new app name. Example: {g_python_cmd} make.py create my_new_app')
    print(f'\tIf you do not provide a name, Cursor AI will generate one for you based on your requested functionality.\n')
    print('clean: Clean all project artifacts.')
    print('\tTo clean all the apps, add the option "all" (i.e. clean all).\n')
    print('build or package: Create the app archive tar.gz file.')
    print('\tTo build all the apps, add the option "all" (i.e. build all).')
    print('\tAny directory containing a package.ini file is considered an app.')
    print('\tThe app name is case-insensitive. The repo root is searched first,')
    print('\tthen the apps/ folder.\n')
    print('status: Fetch and print current app status from the locally connected NCOS device.\n')
    print('install: Secure copy the app archive to a locally connected NCOS device.')
    print('\tThe NCOS device must already be in SDK DEV mode via registration ')
    print('\tand licensing using NCM.')
    print('\tThe app name is case-insensitive. The repo root is searched first,')
    print('\tthen the apps/ folder.')
    print('\tPass a .tar.gz file to install that exact package, for example:')
    print(f'\t\t{g_python_cmd} make.py install "My_App v1.0.0.tar.gz"\n')
    print('start: Start the app on the locally connected NCOS device.\n')
    print('stop: Stop the app on the locally connected NCOS device.\n')
    print('uninstall: Uninstall the app from the locally connected NCOS device.\n')
    print('purge: Purge all apps from the locally connected NCOS device.\n')
    print('deploy: Purge, build, install, and show logs in one step.\n')
    print('setup: Create .venv and install requirements.txt.\n')
    print('contribute: Submit one of your apps to cradlepoint/sdk-samples as a pull request.')
    print(f'\tExample: {g_python_cmd} make.py contribute my_app')
    print('\tForks the repo for you the first time, puts the app on a branch, pushes it')
    print('\tto your fork, and opens the pull request. Your "origin" remote is left')
    print('\tpointing at the upstream repo, so "git pull" keeps working as before.')
    print('\tUses the GitHub CLI when available and offers to download it if not.\n')
    print('uuid: Create a UUID for the app and save it to the package.ini file.\n')
    print('update: Check and update core SDK files from GitHub repository.\n')
    print('\tUpdates: make.py and apps/templates/app_template/cp.py\n')
    print('unit: Run any unit tests associated with selected app.\n')
    print('system: Run any system tests associated with selected app.\n')
    print('help: Print this help information.\n')


# Get the uuid from application package.ini if not already set
def get_app_uuid():
    global g_app_uuid

    if g_app_uuid == '':
        uuid_key = 'uuid'

        # Find the app case-insensitively: repo root first, then apps/
        app_path = find_app_dir(g_app_name)
        if app_path is None:
            return g_app_uuid

        app_config_file = os.path.join(app_path, CONFIG_FILE)
        if not os.path.isfile(app_config_file):
            return g_app_uuid

        config = configparser.ConfigParser()
        config.read(app_config_file)
        # Case-insensitive section lookup
        section_name = find_section(config, os.path.basename(app_path))
        if section_name:
            if uuid_key in config[section_name]:
                g_app_uuid = config[section_name][uuid_key]

                if g_app_uuid == '':
                    # Create a UUID if it does not exist
                    _uuid = str(uuid.uuid4())
                    config.set(section_name, uuid_key, _uuid)
                    with open(app_config_file, 'w') as configfile:
                        config.write(configfile)
                    print('INFO: Created and saved uuid {} in {}'.format(_uuid, app_config_file))
            else:
                print('ERROR: The uuid key does not exist in {}'.format(app_config_file))
        else:
            print('ERROR: The APP_NAME section does not exist in {}'.format(app_config_file))

    return g_app_uuid


def create_settings_file():
    """Create sdk_settings.ini from sdk_settings.ini.example.

    The file is git-ignored because it holds router credentials, so a fresh
    clone will not have one. Returns the path, or None if it could not be
    created.
    """
    repo_root = os.path.dirname(os.path.abspath(__file__))
    settings_file = os.path.join(repo_root, 'sdk_settings.ini')
    example_file = settings_file + '.example'

    contents = ('[sdk]\n'
                'app_name=app_template\n'
                'dev_client_ip=192.168.0.1\n'
                'dev_client_username=admin\n'
                'dev_client_password=mypassword\n')
    source = 'defaults'
    if os.path.isfile(example_file):
        try:
            with open(example_file, 'r') as example:
                contents = example.read()
            source = 'sdk_settings.ini.example'
        except OSError:
            pass

    try:
        with open(settings_file, 'w') as handle:
            handle.write(contents)
    except OSError as ex:
        print('ERROR: Could not create {}: {}'.format(settings_file, ex))
        return None

    print('INFO: Created sdk_settings.ini from {}'.format(source))
    print('      Set your router IP and credentials with:')
    print('        python setup_env.py --configure')
    return settings_file


def warn_if_unconfigured():
    """Print a warning when sdk_settings.ini still has placeholder credentials."""
    placeholders = ('', 'mypassword', 'your_password', 'password', 'changeme')
    if g_dev_client_password in placeholders:
        print('\nWARNING: sdk_settings.ini still has a placeholder password.')
        print('         Set your router credentials with:')
        print('           python setup_env.py --configure\n')


# Setup all the globals based on the OS and the sdk_settings.ini file.
def init(app=None):
    global g_python_cmd
    global g_app_name
    global g_app_archive
    global g_dev_client_ip
    global g_dev_client_username
    global g_dev_client_password

    success = True

    # Keys in sdk_settings.ini
    sdk_key = 'sdk'
    app_key = 'app_name'
    ip_key = 'dev_client_ip'
    username_key = 'dev_client_username'
    password_key = 'dev_client_password'

    if sys.platform == 'win32':
        g_python_cmd = 'python'

    elif sys.platform == 'Darwin':
        # This will exclude the '._' files  in the
        # tar.gz package for OS X.
        os.environ["COPYFILE_DISABLE"] = "1"

    settings_file = os.path.join(os.getcwd(), 'sdk_settings.ini')
    # Also check parent directories (in case running from a subdirectory)
    if not os.path.isfile(settings_file):
        # Walk up to find sdk_settings.ini
        check_dir = os.path.dirname(os.getcwd())
        for _ in range(3):
            candidate = os.path.join(check_dir, 'sdk_settings.ini')
            if os.path.isfile(candidate):
                settings_file = candidate
                break
            check_dir = os.path.dirname(check_dir)

    # sdk_settings.ini is not tracked by git because it holds credentials.
    # Create it from the template so build/clean work on a fresh clone.
    if not os.path.isfile(settings_file):
        settings_file = create_settings_file()
        if settings_file is None:
            return False

    config = configparser.ConfigParser()
    config.read(settings_file)

    # Initialize the globals based on the sdk_settings.ini contents.
    if sdk_key in config:
        if app is not None:
            app_arg = app.rstrip('/\\')
            if is_archive_name(app_arg):
                # A package file was named directly — install exactly that file.
                g_app_archive = app_arg
                g_app_name = archive_to_app_name(app_arg)
            else:
                g_app_name = os.path.basename(app_arg)
            # Normalize to the on-disk folder name so package.ini lookups and
            # package file names match, regardless of the case the user typed.
            resolved = find_app_dir(g_app_name)
            if resolved:
                g_app_name = os.path.basename(resolved)
        elif app_key in config[sdk_key]:
            g_app_name = config[sdk_key][app_key]
        else:
            success = False
            print('ERROR 1: The {} key does not exist in {}'.format(app_key, settings_file))

        if g_app_name == '':
            print('The app_name key is empty in {}'.format(settings_file))

        if ip_key in config[sdk_key]:
            g_dev_client_ip = config[sdk_key][ip_key]
        else:
            success = False
            print('ERROR 2: The {} key does not exist in {}'.format(ip_key, settings_file))

        if username_key in config[sdk_key]:
            g_dev_client_username = config[sdk_key][username_key]
        else:
            success = False
            print('ERROR 3: The {} key does not exist in {}'.format(username_key, settings_file))

        if password_key in config[sdk_key]:
            g_dev_client_password = config[sdk_key][password_key]
        else:
            success = False
            print('ERROR 4: The {} key does not exist in {}'.format(password_key, settings_file))
    else:
        success = False
        print('ERROR 5: The {} section does not exist in {}'.format(sdk_key, settings_file))

    return success


if __name__ == "__main__":
    # Default is no arguments given.
    if len(sys.argv) < 2:
        output_help()
        sys.exit(0)

    utility_name = str(sys.argv[1]).lower()
    option = None
    if len(sys.argv) > 2:
        option = str(sys.argv[2])

    if utility_name in ['clean', 'package', 'build', 'uuid', 'status', 'start', 'stop', 'install', 'uninstall', 'purge', 'update', 'deploy']:
        # Load the settings from the sdk_settings.ini file.
        if not init(option):
            sys.exit(0)
        if utility_name not in ['install', 'purge']:
            get_app_uuid()
        # Commands that talk to the router need real credentials.
        if utility_name in ['status', 'start', 'stop', 'install', 'uninstall', 'purge', 'deploy']:
            warn_if_unconfigured()

    if utility_name == 'clean':
        if option == 'all':
            clean_all()
        else:
            clean()

    elif utility_name in ['package', 'build']:
        if option == 'all':
            package_all()
        else:
            package()

    elif utility_name == 'create':
        create(option)

    elif utility_name == 'status':
        status()

    elif utility_name == 'install':
        install()

    elif utility_name == 'start':
        start()

    elif utility_name == 'stop':
        stop()

    elif utility_name == 'uninstall':
        uninstall()

    elif utility_name == 'purge':
        purge()

    elif utility_name == 'deploy':
        deploy()

    elif utility_name == 'setup':
        setup()

    elif utility_name == 'contribute':
        contribute(option)

    elif utility_name == 'uuid':
        # This is handled in init()
        pass

    elif utility_name == 'update':
        update()

    elif utility_name == 'unit':
        # load any tests in app/test/unit
        app_test_path = os.path.join(g_app_name, 'test', 'unit')
        suite = unittest.defaultTestLoader.discover(app_test_path)
        # change to the app dir so app files can be properly imported
        os.chdir(g_app_name)
        # add the current path to sys path so we can directly import
        sys.path.append(os.getcwd())
        # run suite
        unittest.TextTestRunner().run(suite)

    elif utility_name == 'system':
        # load any tests in app/test/unit
        app_test_path = os.path.join(g_app_name, 'test', 'system')
        suite = unittest.defaultTestLoader.discover(app_test_path)

        # try to add IP and auth info to system test classes
        def iterate_tests(test_suite_or_case):
            try:
                suite = iter(test_suite_or_case)
            except TypeError:
                yield test_suite_or_case
            else:
                for test in suite:
                    for subtest in iterate_tests(test):
                        yield subtest

        for test in iterate_tests(suite):
            try:
                test.DEV_CLIENT_IP = g_dev_client_ip
                test.DEV_CLIENT_USER = g_dev_client_username
                test.DEV_CLIENT_PASS = g_dev_client_password
            except Exception as e:
                # if classes don't accept it ignore
                pass

        # change to the app dir so app files can be properly imported
        os.chdir(g_app_name)
        # add the current path to sys path so we can directly import
        sys.path.append(os.getcwd())
        # run suite
        unittest.TextTestRunner().run(suite)

    else:
        output_help()

    sys.exit(0)