mkit-cli 0.3.1__py3-none-any.whl

mkit/secrets.py

@@ -0,0 +1,148 @@
+"""Credentials, from two .env files, never from the repo tree.
+
+    ~/.mkit/.env        shared by every app: the Play service account (one
+                        developer account), Telegram, the reports bucket
+    <project>/.env      this app only: its Firebase service account, overrides
+
+The shell environment wins over both, then the project file, then the user
+file. A credential is JSON, stored one of two ways:
+
+    MKIT_<NAME>_JSON_BASE64=eyJ0eXBlIjoi...    base64, survives .env quoting
+    MKIT_<NAME>_FILE=C:/keys/play.json          a path outside the repo
+
+The unprefixed spelling (<NAME>_JSON_BASE64) is accepted too, because the
+older per-project kits and CI used it.
+
+Every secret value that is read is registered with the output layer, so it is
+masked if it ever reaches a log line, an error, or a JSON result.
+"""
+import base64
+import binascii
+import json
+import os
+from pathlib import Path
+
+from . import config
+from .errors import CredentialMissing
+
+# name -> what it is for; doctor and error hints use the description.
+KNOWN = {
+    'PLAY_SERVICE_ACCOUNT': 'Google Play Android Publisher service account (JSON)',
+    'FIREBASE_SERVICE_ACCOUNT': "Firebase/Google Cloud service account for this app's project (JSON)",
+    'TELEGRAM': 'Telegram bot, JSON {"bot_token": "...", "chat_id": "..."}',
+}
+
+_registered = set()
+
+
+def register(value):
+    """Mark a string as secret so the output layer masks it."""
+    if isinstance(value, str) and len(value) >= 8:
+        _registered.add(value)
+
+
+def redact(text):
+    if not isinstance(text, str) or not _registered:
+        return text
+    for secret in sorted(_registered, key=len, reverse=True):
+        if secret in text:
+            text = text.replace(secret, '***')
+    return text
+
+
+def parse_env_file(path):
+    """KEY=VALUE lines; # comments; optional quotes. No interpolation."""
+    values = {}
+    try:
+        with open(path, encoding='utf-8-sig') as f:
+            lines = f.read().splitlines()
+    except FileNotFoundError:
+        return values
+    for raw in lines:
+        line = raw.strip()
+        if not line or line.startswith('#') or '=' not in line:
+            continue
+        key, value = line.split('=', 1)
+        key = key.strip()
+        if key.startswith('export '):
+            key = key[7:].strip()
+        value = value.strip()
+        if len(value) >= 2 and value[0] == value[-1] and value[0] in '"\'':
+            value = value[1:-1]
+        values[key] = value
+    return values
+
+
+class Secrets:
+    def __init__(self, project_root=None, user_home=None):
+        self.user_file = Path(user_home or config.home()) / '.env'
+        self.project_file = Path(project_root) / '.env' if project_root else None
+        self._user = parse_env_file(self.user_file)
+        self._project = parse_env_file(self.project_file) if self.project_file else {}
+
+    def lookup(self, key):
+        """(value, source) for a plain key, or (None, None)."""
+        if os.environ.get(key):
+            return os.environ[key], 'environment'
+        if self._project.get(key):
+            return self._project[key], str(self.project_file)
+        if self._user.get(key):
+            return self._user[key], str(self.user_file)
+        return None, None
+
+    def value(self, key, default=None):
+        """A plain setting such as MKIT_PLAY_REPORTS_BUCKET."""
+        for candidate in (key, key[5:] if key.startswith('MKIT_') else None):
+            if candidate:
+                found, _ = self.lookup(candidate)
+                if found:
+                    return found
+        return default
+
+    def _raw(self, name):
+        for prefix in ('MKIT_', ''):
+            b64, source = self.lookup(f'{prefix}{name}_JSON_BASE64')
+            if b64:
+                return 'base64', b64, source
+            path, source = self.lookup(f'{prefix}{name}_FILE')
+            if path:
+                return 'file', path, source
+        return None, None, None
+
+    def source(self, name):
+        """Where a credential would come from, for doctor. None if absent."""
+        _, _, source = self._raw(name)
+        return source
+
+    def has(self, name):
+        return self._raw(name)[0] is not None
+
+    def json(self, name, required=True):
+        """The credential as a dict. Missing and `required` raises exit 3 with
+        a hint naming the exact key and file to put it in."""
+        form, raw, source = self._raw(name)
+        if form is None:
+            if not required:
+                return None
+            raise CredentialMissing(
+                f'{KNOWN.get(name, name)} is not set',
+                hint=(f'Add MKIT_{name}_JSON_BASE64=<base64 of the JSON> to '
+                      f'{self.project_file or "<project>/.env"} (this app) or '
+                      f'{self.user_file} (all apps). `mkit doctor` shows what is set.'),
+                code=f'MISSING_{name}')
+        register(raw)
+        try:
+            if form == 'base64':
+                text = base64.b64decode(''.join(raw.split()), validate=True).decode('utf-8')
+            else:
+                text = Path(raw).expanduser().read_text(encoding='utf-8-sig')
+            data = json.loads(text)
+        except (binascii.Error, UnicodeDecodeError, ValueError, OSError) as e:
+            raise CredentialMissing(
+                f'{name} from {source} could not be read as JSON ({type(e).__name__})',
+                hint='Re-encode it: PowerShell [Convert]::ToBase64String([IO.File]::'
+                     'ReadAllBytes("key.json")), macOS/Linux base64 -w 0 key.json',
+                code=f'BAD_{name}') from e
+        for field in ('private_key', 'private_key_id', 'bot_token'):
+            register(data.get(field))
+        return data

mkit/toolchain.py

@@ -0,0 +1,210 @@
+"""Finding the tools a build needs: Android SDK, adb, emulator, a JDK, Gradle.
+
+Nothing here is per project except where a project may pin a value in
+mkit.toml ([app].java_home) or the environment (MKIT_JAVA_HOME, JAVA_HOME,
+ANDROID_HOME).
+"""
+import glob
+import os
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+from .errors import MkitError
+
+EXE = '.exe' if os.name == 'nt' else ''
+
+# Gradle 8 runs on JDK 17-24. Android Studio's bundled jbr is tried last: recent
+# Studio builds ship a JDK newer than Gradle 8 accepts.
+JDK_MIN, JDK_MAX = 17, 24
+JDK_CANDIDATES = (
+    r'C:\Program Files\Microsoft\jdk-17*',
+    r'C:\Program Files\Microsoft\jdk-21*',
+    r'C:\Program Files\Eclipse Adoptium\jdk-17*',
+    r'C:\Program Files\Eclipse Adoptium\jdk-21*',
+    r'C:\Program Files\Java\jdk-17*',
+    r'C:\Program Files\Java\jdk-21*',
+    os.path.join(str(Path.home()), '.jdks', 'jbr-17*'),
+    os.path.join(str(Path.home()), '.jdks', '*-17*'),
+    os.path.join(str(Path.home()), '.jdks', '*-21*'),
+    '/usr/lib/jvm/*-17*',
+    '/usr/lib/jvm/*-21*',
+    '/Library/Java/JavaVirtualMachines/*17*/Contents/Home',
+    '/Library/Java/JavaVirtualMachines/*21*/Contents/Home',
+    r'C:\Program Files\Android\Android Studio\jbr',
+    os.path.join(os.environ.get('LOCALAPPDATA', ''), 'Programs', 'Android Studio', 'jbr'),
+    '/Applications/Android Studio.app/Contents/jbr/Contents/Home',
+    '/opt/android-studio/jbr',
+)
+
+
+# Where Android Studio lives, newest first within a pattern. The Toolbox keeps
+# every build in its own folder, so those are globbed and sorted.
+STUDIO_CANDIDATES = (
+    os.path.join(os.environ.get('LOCALAPPDATA', ''), 'Programs', 'Android Studio*', 'bin', 'studio64.exe'),
+    r'C:\Program Files\Android\Android Studio*\bin\studio64.exe',
+    os.path.join(os.environ.get('LOCALAPPDATA', ''), 'JetBrains', 'Toolbox', 'apps', '*ndroid*',
+                 '**', 'bin', 'studio64.exe'),
+    os.path.join(os.environ.get('LOCALAPPDATA', ''), 'Programs', 'Android Studio*', 'bin', 'studio.exe'),
+    '/Applications/Android Studio*.app/Contents/MacOS/studio',
+    os.path.join(str(Path.home()), 'Applications', 'Android Studio*.app', 'Contents', 'MacOS', 'studio'),
+    '/opt/android-studio*/bin/studio.sh',
+    '/usr/local/android-studio*/bin/studio.sh',
+    os.path.join(str(Path.home()), '.local', 'share', 'JetBrains', 'Toolbox', 'apps', '*ndroid*',
+                 '**', 'bin', 'studio.sh'),
+)
+
+STUDIO_EXES = ('studio64.exe', 'studio.exe') if os.name == 'nt' else ('studio.sh', 'studio')
+
+
+def _studio_inside(path):
+    """The launcher inside a folder somebody pinned: an install dir, a macOS
+    bundle, or the bin/ folder itself."""
+    path = Path(path)
+    if path.is_file():
+        return str(path)
+    for relative in ('Contents/MacOS/studio', *(f'bin/{e}' for e in STUDIO_EXES), *STUDIO_EXES):
+        found = path / relative
+        if found.is_file():
+            return str(found)
+    return None
+
+
+def studio(project=None):
+    """Android Studio's launcher: [app].studio or MKIT_STUDIO taken as given,
+    then the usual install locations, then PATH."""
+    pinned = (project.get('app.studio') if project else None) or os.environ.get('MKIT_STUDIO')
+    if pinned:
+        found = _studio_inside(pinned)
+        if not found:
+            raise MkitError(f'studio {pinned} is not an Android Studio launcher', code='TOOL_MISSING',
+                            hint='Point it at studio64.exe / studio.sh, or at the install folder.')
+        return found
+    for pattern in STUDIO_CANDIDATES:
+        for candidate in sorted(glob.glob(pattern, recursive=True), reverse=True):
+            if Path(candidate).is_file():
+                return candidate
+    for name in STUDIO_EXES:
+        found = shutil.which(name)
+        if found:
+            return found
+    raise MkitError('Android Studio not found', code='TOOL_MISSING',
+                    hint='Install it, or set studio under [app] in mkit.toml (or MKIT_STUDIO) '
+                         'to the studio64.exe / studio.sh path.')
+
+
+def tool(name):
+    """A PATH tool's full path. shutil.which follows PATHEXT, so firebase.cmd
+    and flutter.bat launch without shell=True."""
+    path = shutil.which(name)
+    if not path:
+        raise MkitError(f'{name} not found on PATH', code='TOOL_MISSING',
+                        hint=f'Install {name} or add it to PATH, then re-run `mkit doctor`.')
+    return path
+
+
+def _local_properties(root):
+    for props in (root / 'local.properties', root / 'android' / 'local.properties'):
+        if props.is_file():
+            for line in props.read_text(encoding='utf-8', errors='replace').splitlines():
+                m = re.match(r'\s*sdk\.dir\s*=\s*(.+?)\s*$', line)
+                if m:
+                    return Path(m.group(1).replace('\\\\', '\\').replace('\\:', ':'))
+    return None
+
+
+def sdk_dir(root=None):
+    if root is not None:
+        found = _local_properties(Path(root))
+        if found and found.is_dir():
+            return found
+    for key in ('ANDROID_HOME', 'ANDROID_SDK_ROOT'):
+        if os.environ.get(key) and Path(os.environ[key]).is_dir():
+            return Path(os.environ[key])
+    guess = (Path(os.environ.get('LOCALAPPDATA', '')) / 'Android' / 'Sdk' if os.name == 'nt'
+             else Path.home() / ('Library/Android/sdk' if os.uname().sysname == 'Darwin' else 'Android/Sdk'))
+    return guess if guess.is_dir() else None
+
+
+def adb(root=None):
+    """The SDK's adb before any on PATH: other tools (scrcpy, phone suites)
+    ship their own, and two adb versions keep killing each other's server."""
+    sdk = sdk_dir(root)
+    if sdk:
+        exe = sdk / 'platform-tools' / f'adb{EXE}'
+        if exe.is_file():
+            return str(exe)
+    found = shutil.which('adb')
+    if found:
+        return found
+    raise MkitError('adb not found', code='TOOL_MISSING',
+                    hint='Install the Android SDK platform-tools, or set ANDROID_HOME.')
+
+
+def emulator(root=None):
+    sdk = sdk_dir(root)
+    exe = sdk / 'emulator' / f'emulator{EXE}' if sdk else None
+    if not exe or not exe.is_file():
+        raise MkitError('Android emulator not found', code='TOOL_MISSING',
+                        hint='Install it from the SDK Manager, or set sdk.dir in local.properties.')
+    return str(exe)
+
+
+def java_major(home):
+    java = Path(home) / 'bin' / f'java{EXE}'
+    if not java.is_file():
+        return 0
+    try:
+        out = subprocess.run([str(java), '-version'], capture_output=True, text=True, timeout=30).stderr
+    except Exception:
+        return 0
+    m = re.search(r'version "(\d+)', out)
+    return int(m.group(1)) if m else 0
+
+
+def find_jdk(project=None):
+    """A JDK for Gradle (JAVA_HOME) and the Android SDK (ANDROID_HOME), both
+    exported for the processes we spawn. See _find_jdk for the JDK order."""
+    jdk = _find_jdk(project)
+    if not os.environ.get('ANDROID_HOME') and not os.environ.get('ANDROID_SDK_ROOT'):
+        # A checkout without local.properties (it is gitignored) still builds.
+        sdk = sdk_dir(project.root if project else None)
+        if sdk:
+            os.environ['ANDROID_HOME'] = str(sdk)
+    return jdk
+
+
+def _find_jdk(project=None):
+    """A JDK Gradle accepts, exported as JAVA_HOME for the processes we spawn.
+
+    Order: [app].java_home / MKIT_JAVA_HOME (taken as given), JAVA_HOME if it is
+    in range, then the first candidate in range. Deliberately not left to
+    `flutter build`, which prefers Android Studio's bundled JDK -- the one that
+    is often too new.
+    """
+    pinned = project.get('app.java_home') if project else os.environ.get('MKIT_APP_JAVA_HOME')
+    pinned = pinned or os.environ.get('MKIT_JAVA_HOME')
+    if pinned:
+        if not java_major(pinned):
+            raise MkitError(f'java_home {pinned} has no bin/java', code='TOOL_MISSING')
+        os.environ['JAVA_HOME'] = str(pinned)
+        return str(pinned)
+    current = os.environ.get('JAVA_HOME', '').rstrip('\\/')
+    if current and JDK_MIN <= java_major(current) <= JDK_MAX:
+        return current
+    for pattern in JDK_CANDIDATES:
+        for candidate in sorted(glob.glob(pattern), reverse=True):
+            if JDK_MIN <= java_major(candidate) <= JDK_MAX:
+                os.environ['JAVA_HOME'] = candidate
+                return candidate
+    raise MkitError(f'no JDK {JDK_MIN}-{JDK_MAX} found', code='TOOL_MISSING',
+                    hint='Install JDK 17 or 21, or set java_home under [app] in mkit.toml.')
+
+
+def gradlew(android_dir):
+    path = Path(android_dir) / ('gradlew.bat' if os.name == 'nt' else 'gradlew')
+    if not path.is_file():
+        raise MkitError(f'no Gradle wrapper at {path}', code='TOOL_MISSING',
+                        hint='Commit the Gradle wrapper (gradlew, gradlew.bat, gradle/wrapper).')
+    return str(path)

mkit_cli-0.3.1.dist-info/METADATA

@@ -0,0 +1,179 @@
+Metadata-Version: 2.5
+Name: mkit-cli
+Version: 0.3.1
+Summary: Release Android apps to Google Play from the command line: build, upload, listing, screenshots, data safety, in-app products, vitals and Firebase, in one tool built for humans and AI agents.
+Project-URL: Homepage, https://github.com/almasumdev/mkit-cli
+Project-URL: Documentation, https://github.com/almasumdev/mkit-cli/blob/main/docs/commands.md
+Project-URL: Repository, https://github.com/almasumdev/mkit-cli
+Project-URL: Issues, https://github.com/almasumdev/mkit-cli/issues
+Project-URL: Changelog, https://github.com/almasumdev/mkit-cli/blob/main/CHANGELOG.md
+Author: Nurullah Al-Masum
+License-Expression: MIT
+License-File: LICENSE
+Keywords: android,aso,firebase,flutter,google-play,release
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: System :: Software Distribution
+Requires-Python: >=3.11
+Requires-Dist: google-api-python-client>=2.150
+Requires-Dist: google-auth>=2.35
+Requires-Dist: pillow>=11
+Requires-Dist: requests>=2.32
+Description-Content-Type: text/markdown
+
+# mkit
+
+[![tests](https://github.com/almasumdev/mkit-cli/actions/workflows/tests.yml/badge.svg)](https://github.com/almasumdev/mkit-cli/actions/workflows/tests.yml)
+[![licence: MIT](https://img.shields.io/badge/licence-MIT-blue.svg)](https://github.com/almasumdev/mkit-cli/blob/main/LICENSE)
+
+One command-line tool for everything around an Android app that is not writing
+it: build and install on a device, release to Google Play, keep the store
+listing, screenshots, data safety and in-app products in your repo, read
+installs, vitals, crashes and reviews, check search rank, and drive the
+Firebase side (Firestore rules, Remote Config, an in-app update document).
+
+Flutter and native Kotlin apps, including apps with a Wear OS module.
+
+```bash
+mkit deploy          # bump, build, upload to Play, publish, notify, push
+mkit run -p          # build and install on the phone
+mkit status          # what every track holds right now
+mkit crashes         # what is breaking in production
+```
+
+A release is one command. `mkit deploy` bumps the version, commits it, builds
+the bundle, uploads it with its mapping file and release notes, stages it on a
+track, writes the update document, sends a message, and pushes — and if
+anything fails before Play accepts the build, the version bump undoes itself so
+the repo never claims a release that did not happen.
+
+## Why it exists
+
+Shipping an Android app means a dozen small jobs that live in different places:
+a Gradle command, the Play Console, the Firebase console, a screenshot folder
+somebody renamed, a changelog nobody updated. Each is easy; together they are a
+release day. mkit puts them behind one tool, with the app's settings in one
+file, so the same release happens the same way every time — and so an AI agent
+can run the safe parts without being handed your Play Console password.
+
+It was built to ship a small studio's apps and has been doing that for a while.
+It is opinionated where opinions save time and configurable where apps really
+differ.
+
+## Install
+
+Requires Python 3.11 or newer. [uv](https://docs.astral.sh/uv/) is the easiest
+way in, and installs mkit as a command of its own rather than into a project:
+
+```bash
+uv tool install mkit-cli
+mkit --version
+```
+
+With pipx: `pipx install mkit-cli`. With pip: `pip install mkit-cli`.
+
+The latest from `main`, between releases:
+`uv tool install git+https://github.com/almasumdev/mkit-cli`
+
+`mkit self status` says whether a newer release is out, and `mkit self update`
+gives the upgrade command for whichever of these installed it.
+
+## Getting started
+
+In an app's folder:
+
+```bash
+mkit init            # writes mkit.toml, asking what it cannot work out
+mkit doctor          # what is configured, what is missing, and what to add
+```
+
+`mkit.toml` is the whole of an app's configuration:
+
+```toml
+[app]
+name    = "My App"
+kind    = "flutter"          # flutter | android | android-wear
+package = "com.example.app"
+
+[play]                       # switches Play features on
+
+[store]                      # store listing, art and data safety in the repo
+listing_dir = "store/listing"
+```
+
+Credentials never live in that file. A Google Play service account goes in
+`.env` (per app) or `~/.mkit/.env` (shared); `mkit doctor` names the exact key
+when one is missing, and never prints a secret. Every setting is documented in
+[docs/config.md](https://github.com/almasumdev/mkit-cli/blob/main/docs/config.md).
+
+## What it does
+
+| | |
+|---|---|
+| **Develop** | `run`, `devices`, `logs`, `emu`, `studio`, `gradle`, `version`, `bump` |
+| **Release** | `deploy`, `status`, `promote`, `rollout`, `share` |
+| **Store** | `listing`, `whatsnew`, `datasafety`, `testers`, `art` |
+| **Money** | `products`, `prices` |
+| **Insight** | `stats`, `vitals`, `crashes`, `reviews`, `aso` |
+| **Firebase** | `rules`, `config`, `remoteconfig`, `firebase` |
+
+Every command, flag and example: [docs/commands.md](https://github.com/almasumdev/mkit-cli/blob/main/docs/commands.md),
+generated from the code so it cannot describe a flag that does not exist.
+
+Commands are classed by what they can change — `read`, `plan`, `write`,
+`publish` — and anything in the `publish` class refuses to run without an
+explicit confirmation naming the package.
+
+Some things have no API and must be done in the Play Console. `mkit manual`
+lists them, so you know what is left rather than discovering it at release
+time.
+
+## Working with AI agents
+
+mkit answers in JSON whenever it is not attached to a terminal, with one
+envelope on stdout and a documented exit code per outcome, so an agent can
+branch on a result instead of reading prose. [AGENTS.md](https://github.com/almasumdev/mkit-cli/blob/main/AGENTS.md) is the
+contract: which commands are safe to run unasked, which need a human to say so,
+and what an agent must never do.
+
+## Documentation
+
+| | |
+|---|---|
+| [docs/commands.md](https://github.com/almasumdev/mkit-cli/blob/main/docs/commands.md) | every command and flag |
+| [docs/config.md](https://github.com/almasumdev/mkit-cli/blob/main/docs/config.md) | `mkit.toml`, the store and keyword files, credentials |
+| [docs/store.md](https://github.com/almasumdev/mkit-cli/blob/main/docs/store.md) | the `store/` folder: what lives where, in every language |
+| [docs/store-art.md](https://github.com/almasumdev/mkit-cli/blob/main/docs/store-art.md) | screenshots and the feature graphic, built from real captures |
+| [docs/in-app-update.md](https://github.com/almasumdev/mkit-cli/blob/main/docs/in-app-update.md) | how an app should check for updates: Play first, your policy second |
+| [docs/news-topics.md](https://github.com/almasumdev/mkit-cli/blob/main/docs/news-topics.md) | news and offer notifications over FCM topics |
+| [AGENTS.md](https://github.com/almasumdev/mkit-cli/blob/main/AGENTS.md) | the agent contract |
+| [CONTRIBUTING.md](https://github.com/almasumdev/mkit-cli/blob/main/CONTRIBUTING.md) | changing mkit, tests, versioning |
+| [SECURITY.md](https://github.com/almasumdev/mkit-cli/blob/main/SECURITY.md) | what counts as a security bug here, and how to report it |
+
+## Status and scope
+
+Developed on Windows against real apps on Google Play; the code paths for
+macOS and Linux exist but are less travelled, and there is no CI yet. The test
+suite runs against a fake Play service — nothing in the tests touches a real
+account.
+
+It does not: create an app in the Play Console, answer content rating or target
+audience questionnaires, manage tester email lists (the API only takes Google
+Groups), or publish for you when managed publishing is on. `mkit manual` is the
+full list.
+
+Issues and pull requests are welcome. If you use it for your own apps, I would
+like to hear what broke.
+
+## Licence
+
+MIT. See [LICENSE](https://github.com/almasumdev/mkit-cli/blob/main/LICENSE).

mkit_cli-0.3.1.dist-info/RECORD

@@ -0,0 +1,48 @@
+mkit/__init__.py,sha256=iUQkWEnJBDh_PVSwZzs2sDbiKY0IYTDKqeV75nFY0-4,227
+mkit/art.py,sha256=2Nkgxzwql02wTQfSeVmgfmufryjjx_Q55Tulh0C-T70,59074
+mkit/aso.py,sha256=XMWDkzAgt40Vg9INSE6War9AEwflNGuznGpCc-H_MzE,15291
+mkit/cli.py,sha256=exINjh598DDfRHhI9VuUCTyaE0fLhdPANBxMpD2sK7M,7246
+mkit/config.py,sha256=mGTMeC90WEVv_LZh8xby9HnniXA2eb7laLSRrv6sfVY,5252
+mkit/datasafety.py,sha256=afHlHx90nV4niOM1qBoZOVK0TR0dH9iPCtFOifAv_18,13066
+mkit/device.py,sha256=8Ooe_MjELX9E4rw4kmBx_aDyE7BFTZj5eRLGNZty9IY,10643
+mkit/docgen.py,sha256=xAZaulKML9j-1xJxuj0EAcWh4G1FcyPgHLoVxeO2Xog,4518
+mkit/errors.py,sha256=1x067e8l288UMeIpG3s6SdxY03pC-7OJLiCpecapnyk,1889
+mkit/git.py,sha256=ofCbNL8Knyz3Sf2msXEQsVSiq-syXVV0zHjgExpnkkk,3705
+mkit/hooks.py,sha256=csh1TPRvL3v2lhNTHUGPj89cNHWHKnj-JxI61m_Gws8,1083
+mkit/kinds.py,sha256=PuQeu4O7mzVV_9VCksY0V3D5tbXDkTfMF43ylsGkhYc,13277
+mkit/notify.py,sha256=fM653ABGjapZd8vdr2IcixAOltPCwpgRxXbdbPPzKEI,1676
+mkit/output.py,sha256=HQLDywJdGfT2TMwiEm46q4qeiCm9UhbnbZVjtQVHGO4,13782
+mkit/proc.py,sha256=-dD8_KKnq4yFaVDr7Nzy5P0EZscaGykt0-Hr-W1OlT4,6179
+mkit/registry.py,sha256=rAL7MwvQPSEhtdUchiEP7W-3druQR552Q1E-GqRD9K4,3610
+mkit/safety.py,sha256=jwShFLnxVHxKyRcAqfSW-gOLMuH4Z3mtOmlk22adQLE,2721
+mkit/secrets.py,sha256=RpTLMzY8096Vvx1Uikp_vUu-9gu7Jfot9W_J6VBz2Ek,5693
+mkit/toolchain.py,sha256=UlPMQ4P0guEGBroG-qAJw8yBeOS6vugGHcvl4OV_WwU,8770
+mkit/cloud/__init__.py,sha256=lcRs1Xr8vS4gTfG1gcHpqiNJDs2wkivGkWZ6cp6LY9s,85
+mkit/cloud/auth.py,sha256=6WPNauTQ9fPiX9QFmhaaVhRnIjYqiN-TzQnIPneB8AQ,5364
+mkit/cloud/fbproject.py,sha256=pGQdS6Q4ycnq0XKmYAo31oz0u-NQno0crJPHmqhE5dM,7731
+mkit/cloud/firebase.py,sha256=KP6IIzfmnnojBWWtNrW_UHNtpUUpk90lh5Pzns8SBos,7453
+mkit/cloud/insight.py,sha256=JtqYB3LNsEPfWJOZTUwuMyDzWFIKkpujpWtAJs3QFME,12947
+mkit/cloud/money.py,sha256=YY_6uGrmGvkOOeCrlblJXlbX128j5uD6op1lHC52Mtk,32107
+mkit/cloud/play.py,sha256=PVbctsOnVzpKdtu8FiL3X1FzrXG0-q8_qqMbsubTvlo,23263
+mkit/cloud/store.py,sha256=g-7Dgmd1B56RLWT5kppdWNXuQLffz0VqjrG0k3niQ-s,17639
+mkit/commands/__init__.py,sha256=99Fc-7Nz1XPlqr55vvnrTg3M3YmxKmCkLuqLjH4Lep8,172
+mkit/commands/art.py,sha256=9hf8sHVRBU8VUwu_9eKT6iWjHZ-QsI9ogTORHTkWIB0,5360
+mkit/commands/aso.py,sha256=pJs8CPQNRQqvkzDcNtv_v8ILS3sZ88QSlo9zbv0_h-Q,7090
+mkit/commands/dev.py,sha256=aH-BtTGQA0-QJndRjejfwtdX8EaingcTCHwIrzb46XI,13042
+mkit/commands/doctor.py,sha256=PU6YRZ_ZC-WU5jJxyz6Ue1NoZW2qkJUsAu2zHvYeXBA,8103
+mkit/commands/firebase_cmds.py,sha256=Q7MriBDRI4A-mtRgF333uLuO_z-n36_bYhpka3V0IPM,9633
+mkit/commands/init.py,sha256=e-p2tQIX9XGDStivRR2UNDp_Nlh-Vt_5yuHcE2TO_LA,8227
+mkit/commands/insight.py,sha256=53FFD6cua2O9OzR3Yud1pptStGSdJccjf5QQGyD9jns,5523
+mkit/commands/meta.py,sha256=6mtY6AKLj0eQg2eU95cJFXUwFuGcvSOWIFc_Plmspug,5010
+mkit/commands/money.py,sha256=K5-ZT2I8Yc-MDi21QPev0ZQBrS0s9j5xhKslTFOfyuY,6325
+mkit/commands/release.py,sha256=XrHv67WWXLYYYqL0k3nT9_Zi688lC3iG9C5SvoyaT88,20888
+mkit/commands/selfcmd.py,sha256=hIjJNJIFfadc4yoyeQurBuGKvbsSBqdDOujU75gGQnE,7463
+mkit/commands/store.py,sha256=jGrm8Ty3LFF0SDFxCUiz4YzKKTrs2vJ5X4QQjT70t24,13070
+mkit/data/datasafety-questions.csv,sha256=FrvFSRxZW99rOqj5JEXVtRkm0mp2quKnCP0SqUWI9yw,178026
+mkit/data/art/art.toml,sha256=nJzDLlj-mKsEbE4uwI_4r6dhG6Tq17DT4wLy1tV-XvA,4885
+mkit/data/art/en.json,sha256=xuEPUT_MzCdP2UOKHShTiCTDzjBgof7fzsOJ1SDi6pI,1115
+mkit_cli-0.3.1.dist-info/METADATA,sha256=1b-FmEsLwE1QXX5_nE4d-W9hJd6Io44asiDaH1dG6eo,8349
+mkit_cli-0.3.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+mkit_cli-0.3.1.dist-info/entry_points.txt,sha256=niTcFqsV7EFp871rsGdY6zWQcHxkzaox5Mj7Fa1KSKs,39
+mkit_cli-0.3.1.dist-info/licenses/LICENSE,sha256=3DBcB7wESKA4pgutHnCDuOq55myaF_ftXfhLcE2muC8,1074
+mkit_cli-0.3.1.dist-info/RECORD,,

mkit_cli-0.3.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

mkit_cli-0.3.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mkit = mkit.cli:main

mkit_cli-0.3.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nurullah Al-Masum
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.