mkit-cli 0.3.1__py3-none-any.whl

mkit/commands/init.py

@@ -0,0 +1,213 @@
+"""`mkit init`: link an app folder to the engine.
+
+Writes three small files and nothing else:
+
+    mkit.toml        settings, detected from the project, committed
+    mkit.ps1         PowerShell launcher (./mkit): one Ctrl+C stops it
+    mkit.bat         cmd launcher: runs the installed engine on this folder
+    mkit.sh          macOS/Linux launcher, same thing
+
+and makes sure `.env` (this app's secrets) is gitignored. Existing files are
+left alone unless --force is given.
+"""
+import re
+from pathlib import Path
+
+from .. import __version__
+from ..errors import UsageError
+from ..registry import Arg, command
+
+# No < > | & here: the text is echoed by cmd.exe, which reads those as redirects.
+# The engine that writes a new mkit.toml is the oldest one known to read it.
+REQUIRES = '.'.join(__version__.split('.')[:2])
+
+INSTALL_HINT = 'Install it with: uv tool install mkit-cli  (or pipx install mkit-cli)'
+
+# mkit.exe by full name: plain `mkit` from inside mkit.bat can resolve to this
+# very file (cmd searches the current folder first) and call itself forever.
+BAT = f'''@echo off
+where mkit.exe >nul 2>nul || (echo mkit is not installed. {INSTALL_HINT} 1>&2 & exit /b 9009)
+mkit.exe --project "%~dp0." %*
+'''
+
+# PowerShell runs .\mkit.ps1 ahead of .\mkit.bat for `./mkit`, and a script,
+# unlike a batch file, stops on one Ctrl+C: cmd's "Terminate batch job (Y/N)?"
+# only exists for .bat/.cmd.
+PS1 = f'''# mkit launcher for PowerShell: ./mkit run
+if (-not (Get-Command mkit.exe -ErrorAction SilentlyContinue)) {{
+    Write-Error 'mkit is not installed. {INSTALL_HINT}'
+    exit 9009
+}}
+& mkit.exe --project $PSScriptRoot @args
+exit $LASTEXITCODE
+'''
+
+SH = f'''#!/usr/bin/env sh
+set -eu
+command -v mkit >/dev/null 2>&1 || {{ echo "mkit is not installed. {INSTALL_HINT}" >&2; exit 127; }}
+exec mkit --project "$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)" "$@"
+'''
+
+_APP_ID = re.compile(r'''applicationId\s*=?\s*["']([\w.]+)["']''')
+
+
+def _read(path):
+    try:
+        return path.read_text(encoding='utf-8', errors='replace')
+    except OSError:
+        return ''
+
+
+def detect(root):
+    """(kind, package, name) guessed from the files present; any may be None."""
+    root = Path(root)
+    if (root / 'pubspec.yaml').is_file():
+        kind = 'flutter'
+        gradle_dir = root / 'android' / 'app'
+        m = re.search(r'^name:\s*(\S+)', _read(root / 'pubspec.yaml'), re.M)
+        name = m.group(1).replace('_', ' ').title().replace(' ', '') if m else None
+    else:
+        gradle_dir = root / 'app'
+        wear = (root / 'wear').is_dir() and any((root / 'wear' / f).is_file()
+                                                for f in ('build.gradle.kts', 'build.gradle'))
+        kind = 'android-wear' if wear else 'android'
+        name = None
+        for settings in ('settings.gradle.kts', 'settings.gradle'):
+            m = re.search(r'rootProject\.name\s*=\s*["\']([^"\']+)', _read(root / settings))
+            if m:
+                name = m.group(1)
+                break
+    package = None
+    for f in ('build.gradle.kts', 'build.gradle'):
+        m = _APP_ID.search(_read(gradle_dir / f))
+        if m:
+            package = m.group(1)
+            break
+    if not (gradle_dir / 'build.gradle.kts').is_file() and not (gradle_dir / 'build.gradle').is_file():
+        kind = kind if kind == 'flutter' else None
+    return kind, package, name or root.name
+
+
+def render_toml(name, kind, package):
+    return f'''# mkit settings for {name}. Secrets never go here: they live in .env
+# (this app) and ~/.mkit/.env (all apps). `mkit doctor` checks everything.
+requires = ">={REQUIRES}"
+
+[app]
+name     = "{name}"
+kind     = "{kind}"            # flutter | android | android-wear
+package  = "{package}"
+activity = ".MainActivity"
+
+# A table switches a feature on. Leave one out and every step that uses it is
+# skipped quietly, because this app does not use it.
+
+# [play]
+# internal_testing_url = ""
+
+# [store]
+# listing_dir  = "store/listing"      # everything the store shows lives under store/
+# art_dir      = "store"
+# icon         = "android/app/src/main/ic_launcher-playstore.png"
+# whatsnew_dir = "distribution/whatsnew"
+
+# [firebase]
+# rules      = true
+# update_doc = "config/app"
+
+# [notify.telegram]
+'''
+
+
+ENV_TEMPLATE = """\
+# Secrets for this app. Gitignored, and never committed - `mkit doctor` names
+# the key it wants when one is missing, and prints none of them.
+#
+# Each is the service account JSON, base64 encoded, on one line:
+#   Windows : [Convert]::ToBase64String([IO.File]::ReadAllBytes("key.json"))
+#   macOS   : base64 -i key.json
+#   Linux   : base64 -w0 key.json
+#
+# Anything every app shares goes in ~/.mkit/.env instead of here.
+
+# Google Play, for releases, the listing, products, reviews and vitals.
+# Play Console > Users and permissions, invite the service account.
+# MKIT_PLAY_SERVICE_ACCOUNT_JSON_BASE64=
+
+# Firebase, for Firestore rules, Remote Config and the update document.
+# Project settings > Service accounts > Generate new private key.
+# MKIT_FIREBASE_SERVICE_ACCOUNT_JSON_BASE64=
+
+# A Telegram bot, if this app sends a message after a release.
+# {"bot_token": "...", "chat_id": 123}, base64 encoded.
+# MKIT_TELEGRAM_JSON_BASE64=
+"""
+
+
+def _ensure_gitignored(root, entry='.env'):
+    gi = root / '.gitignore'
+    text = _read(gi)
+    lines = [l.strip() for l in text.splitlines()]
+    if entry in lines or f'/{entry}' in lines:
+        return False
+    with open(gi, 'a', encoding='utf-8', newline='\n') as f:
+        if text and not text.endswith('\n'):
+            f.write('\n')
+        f.write(f'\n# mkit: this app\'s secrets\n{entry}\n')
+    return True
+
+
+@command('init', 'Link this app folder to mkit (mkit.toml + launchers)', risk='write',
+         needs_project=False,
+         args=(Arg('path', 'app folder (default: current folder)', kind='positional', nargs='?'),
+               Arg('kind', 'override the detected kind', choices=('flutter', 'android', 'android-wear')),
+               Arg('package', 'override the detected package id'),
+               Arg('name', 'override the detected app name'),
+               Arg('force', 'overwrite existing mkit.toml and launchers', kind='flag')),
+         examples=('mkit init', 'mkit init H:/flutter/onGoing/listkin --name Listkin'))
+def init(ctx, args):
+    root = Path(args.path or '.').resolve()
+    if not root.is_dir():
+        raise UsageError(f'{root} is not a folder')
+    kind, package, name = detect(root)
+    kind = args.kind or kind
+    package = args.package or package
+    name = args.name or name
+    if not kind:
+        raise UsageError(f'could not tell what kind of app {root} is',
+                         hint='Pass --kind flutter|android|android-wear.')
+
+    written, kept = [], []
+    files = {'mkit.toml': render_toml(name, kind, package or ''), 'mkit.bat': BAT, 'mkit.ps1': PS1,
+             'mkit.sh': SH}
+    # The .env is the step everybody gets stuck on: which keys, in what format,
+    # from where. A commented skeleton answers all three in the folder where it
+    # is needed. It is never replaced, not even with --force: that file holds
+    # the only copy of somebody's credentials.
+    if not (root / '.env').exists():
+        files['.env'] = ENV_TEMPLATE
+    else:
+        kept.append('.env (exists; left alone)')
+    for fname, content in files.items():
+        target = root / fname
+        if target.exists() and not args.force:
+            kept.append(fname)
+            continue
+        newline = '\r\n' if fname.endswith('.bat') else '\n'
+        with open(target, 'w', encoding='utf-8', newline=newline) as f:
+            f.write(content)
+        written.append(fname)
+    if _ensure_gitignored(root):
+        written.append('.gitignore (.env)')
+
+    out = ctx.out
+    if not out.json:
+        out.heading(f'{name}   {kind}   {package or "package not found"}')
+        for f in written:
+            out.line(f'  wrote {f}', 'green')
+        for f in kept:
+            out.line(f'  kept  {f} (exists; --force to replace)', 'dim')
+        out.line()
+        out.line('Next: add secrets to .env, switch features on in mkit.toml, then `mkit doctor`.')
+    return {'root': str(root), 'kind': kind, 'package': package, 'name': name,
+            'written': written, 'kept': kept}

mkit/commands/insight.py

@@ -0,0 +1,110 @@
+"""How the app is doing: installs, conversion, vitals, crashes, reviews."""
+from datetime import datetime, timezone
+
+from .. import safety
+from ..cloud import auth, insight
+from ..registry import Arg, command, group
+
+group('reviews', 'Play reviews: read and reply')
+
+
+def _wrap(fn, what):
+    try:
+        return fn()
+    except Exception as e:
+        raise auth.translate(e, what) from None
+
+
+@command('stats', 'Installs, uninstalls, active devices, store conversion, ratings, countries',
+         risk='read', needs=('play',),
+         args=(Arg('days', 'daily rows to show (human output)', type=int, default=14),))
+def stats(ctx, args):
+    data = _wrap(lambda: insight.stats(ctx), 'Play reports bucket')
+    out = ctx.out
+    if not out.json:
+        if data['window']:
+            out.line(f'{ctx.project.name}   {data["window"][0]} to {data["window"][1]}   '
+                     '(Play reports lag 3-7 days)', 'dim')
+        s, i, r = data['store'], data['installs'], data['ratings']
+        out.heading('store listing')
+        out.line(f'  visitors {s["visitors"]}   acquisitions {s["acquisitions"]}'
+                 + (f'   conversion {s["conversion"]}%' if s['conversion'] is not None else ''))
+        out.heading('installs')
+        out.line(f'  installs {i["installs"]}   uninstalls {i["uninstalls"]}   '
+                 f'net {i["installs"] - i["uninstalls"]:+d}')
+        out.line(f'  active devices: latest {i["active_latest"]}, peak {i["active_peak"]}')
+        out.heading('ratings')
+        out.line(f'  {r["count"]} rating(s)' + (f', average {r["average"]}' if r['average'] else ''))
+        if data['countries']:
+            out.heading('installs by country')
+            out.line('  ' + '   '.join(f'{c} {n}' for c, n in list(data['countries'].items())[:12] if n))
+        if data['daily']:
+            out.heading('daily')
+            out.table([(d['date'], d['installs'], d['uninstalls'], d['active'])
+                       for d in data['daily'][-args.days:]], ('date', 'installs', 'uninstalls', 'active'))
+    return data
+
+
+@command('vitals', 'Crash and ANR rates per version (Play Developer Reporting API)', risk='read',
+         needs=('play',), args=(Arg('days', 'window in days', type=int, default=28),))
+def vitals(ctx, args):
+    data = insight.vitals(ctx, args.days)
+    if not ctx.out.json:
+        for key, label, rate, perceived in (('crash', 'crashes', 'crashRate', 'userPerceivedCrashRate'),
+                                            ('anr', 'ANRs', 'anrRate', 'userPerceivedAnrRate')):
+            block = data[key]
+            ctx.out.heading(f'{label}' + (f'   {block["window"][0]} to {block["window"][1]}' if block.get('window') else ''))
+            if not block['rows']:
+                ctx.out.line(f'  {block.get("note", "no data")}')
+                continue
+            ctx.out.table([(r['versionCode'], r['users'], f'{r.get(rate, 0):.2f}%', f'{r.get(perceived, 0):.2f}%')
+                           for r in block['rows']], ('versionCode', 'users', label, 'user-perceived'))
+        ctx.out.line()
+        ctx.out.line("Play's bad-behaviour thresholds: user-perceived crashes 1.09%, ANRs 0.47%", 'dim')
+    return data
+
+
+@command('crashes', 'Top crash and ANR clusters with where they happen', risk='read', needs=('play',),
+         args=(Arg('limit', 'how many', type=int, default=10),))
+def crashes(ctx, args):
+    issues = insight.crashes(ctx, args.limit)
+    if not ctx.out.json:
+        if not issues:
+            ctx.out.line('no crash or ANR clusters reported')
+        for i in issues:
+            ctx.out.line(f'  {i["reports"]:>5} reports  {i["users"]:>4} users  {i["type"]}  '
+                         f'v{i["firstVersion"]}-{i["lastVersion"]}')
+            ctx.out.line(f'        {i["cause"] or ""}', 'bold')
+            ctx.out.line(f'        {i["location"] or ""}', 'dim')
+    return {'issues': issues}
+
+
+@command('reviews list', 'Reviews with text from the last 7 days (the API limit)', risk='read',
+         needs=('play',),
+         args=(Arg('limit', 'how many', type=int, default=50),
+               Arg('translate', 'translate into this language, e.g. en'),
+               Arg('unanswered', 'only reviews without a reply', kind='flag')))
+def reviews_list(ctx, args):
+    items = _wrap(lambda: insight.reviews(ctx, args.limit, args.translate), 'Play reviews')
+    if args.unanswered:
+        items = [r for r in items if not r['replied']]
+    if not ctx.out.json:
+        if not items:
+            ctx.out.line('no reviews with text in the last 7 days (older ones: `mkit stats` has ratings)')
+        for r in items:
+            when = datetime.fromtimestamp(int(r['date']), timezone.utc).date() if r['date'] else ''
+            ctx.out.line(f'  {"*" * (r["stars"] or 0):5} {when}  {r["author"]}  v{r["version"] or "?"}  '
+                         f'{"replied" if r["replied"] else "NO REPLY"}   id {r["id"]}')
+            ctx.out.line(f'        {r["text"]}')
+    return {'reviews': items}
+
+
+@command('reviews reply', 'Reply to a review (public, 350 characters)', risk='publish', needs=('play',),
+         args=(Arg('id', 'review id from `mkit reviews list`', kind='positional'),
+               Arg('text', 'the reply', kind='positional')))
+def reviews_reply(ctx, args):
+    safety.confirm(ctx, 'Post a public reply to a review', [args.text])
+    if ctx.dry_run:
+        return {'id': args.id, 'text': args.text, 'dry_run': True}
+    _wrap(lambda: insight.reply(ctx, args.id, args.text), 'Play reviews')
+    return {'id': args.id, 'replied': True}

mkit/commands/meta.py

@@ -0,0 +1,84 @@
+"""Commands that describe mkit itself: for agents first, humans second."""
+from .. import __version__
+from ..errors import EXIT_CODES, NotFound
+from ..registry import GROUPS, REGISTRY, RISKS, Arg, command
+
+
+@command('commands', 'List every command with its risk class and what it needs',
+         risk='read', needs_project=False,
+         examples=('mkit commands', 'mkit commands --json'))
+def commands(ctx, args):
+    """Every registered command. In JSON mode each entry carries a JSON Schema of
+    its input, so an agent can build a valid call without reading help text."""
+    entries = [REGISTRY[n].describe() for n in sorted(REGISTRY)]
+    out = ctx.out
+    if not out.json:
+        for risk in RISKS:
+            rows = [(e['name'], e['summary']) for e in entries if e['risk'] == risk]
+            if rows:
+                out.heading(f'{risk}')
+                out.table(rows, ('command', 'what'))
+        out.line()
+        out.line('publish commands always ask first; agents pass --yes --confirm <package>.', 'dim')
+    return {'version': __version__, 'groups': GROUPS, 'commands': entries,
+            'exit_codes': {str(k): v for k, v in EXIT_CODES.items()}}
+
+
+@command('schema', 'Input schema and details of one command', risk='read', needs_project=False,
+         args=(Arg('name', 'command name, e.g. "deploy" or "listing plan"', kind='positional', nargs='+'),),
+         examples=('mkit schema deploy --json', 'mkit schema listing plan'))
+def schema(ctx, args):
+    name = ' '.join(args.name)
+    if name not in REGISTRY:
+        raise NotFound(f'no command "{name}"', hint='`mkit commands` lists them all.')
+    entry = REGISTRY[name].describe()
+    entry['description'] = REGISTRY[name].description
+    if not ctx.out.json:
+        ctx.out.heading(f'mkit {name}   [{entry["risk"]}]')
+        ctx.out.line(entry['description'] or entry['summary'])
+        props = entry['input']['properties']
+        if props:
+            ctx.out.table([(k, v.get('type'), v.get('description', '')) for k, v in props.items()],
+                          ('argument', 'type', 'what'))
+    return entry
+
+
+# What the Play Developer API cannot do, checked against the API reference on
+# 2026-09-18. `applies` narrows the list to what matters for this app.
+MANUAL = (
+    {'id': 'create-app', 'what': 'Create the app and make its first upload',
+     'where': 'Play Console > Create app', 'applies': 'new apps only'},
+    {'id': 'privacy-policy', 'what': 'Set the privacy policy URL (needed before data safety)',
+     'where': 'App content > Privacy policy', 'applies': 'every app'},
+    {'id': 'datasafety-export', 'what': 'Read back the data safety answers Play holds (the API only uploads; `mkit datasafety build` writes the CSV from mkit.toml, `apply` uploads it)',
+     'where': 'App content > Data safety > Export to CSV', 'applies': 'only to check what is declared now'},
+    {'id': 'declarations', 'what': 'App content declarations other than data safety: ads, target '
+     'audience, content rating, permissions and foreground services, account deletion URL',
+     'where': 'App content', 'applies': 'every app, and again when the app changes'},
+    {'id': 'production-access', 'what': 'Production access for a new personal developer '
+     'account: 12 testers opted in for 14 days of closed testing, then apply',
+     'where': 'Play Console > Testing > Closed testing, then Production', 'applies': 'new personal accounts'},
+    {'id': 'app-access', 'what': 'Test credentials for an app behind a sign-in, so Play review '
+     'can get past the login screen', 'where': 'App content > App access', 'applies': 'apps that need an account'},
+    {'id': 'managed-publishing', 'what': 'Turn managed publishing on/off, press Publish, and "Send '
+     'for review" for changes held back', 'where': 'Publishing overview', 'applies': 'when used'},
+    {'id': 'tester-emails', 'what': 'Tester email lists (the API only takes Google Groups)',
+     'where': 'Testing > Testers', 'applies': 'closed testing with email lists'},
+    {'id': 'track-countries', 'what': 'Countries for a testing track (the API can only read them)',
+     'where': 'Testing > track > Countries/regions', 'applies': 'testing tracks'},
+    {'id': 'custom-listings', 'what': 'Custom store listings and store listing experiments',
+     'where': 'Grow users > Store presence', 'applies': 'when used'},
+    {'id': 'crashlytics', 'what': 'Crashlytics issues (no stable service-account API; `mkit crashes` '
+     'reads Play vitals instead)', 'where': 'Firebase console > Crashlytics', 'applies': 'firebase apps'},
+)
+
+
+@command('manual', 'What only Play Console can do (no API), as a checklist', risk='read',
+         needs_project=False, examples=('mkit manual',))
+def manual(ctx, args):
+    if not ctx.out.json:
+        ctx.out.heading('Only in Play Console (no API)')
+        for m in MANUAL:
+            ctx.out.line(f'  - {m["what"]}')
+            ctx.out.line(f'    {m["where"]}   ({m["applies"]})', 'dim')
+    return {'manual': list(MANUAL)}

mkit/commands/money.py

@@ -0,0 +1,152 @@
+"""In-app products, subscriptions and prices."""
+from .. import safety
+from ..cloud import auth, money
+from ..errors import DRIFT
+from ..registry import Arg, command, group
+
+group('products', 'one-time products, their offers, and subscriptions')
+group('prices', "Google Play's regional prices")
+
+
+def _svc(ctx):
+    return auth.play(ctx, timeout=120), ctx.project.get('play.package') or ctx.project.package
+
+
+@command('products list', 'What Play holds: every one-time product and subscription', risk='read',
+         needs=('play',))
+def products_list(ctx, args):
+    svc, package = _svc(ctx)
+    try:
+        products, subs = money.list_remote(svc, package)
+    except Exception as e:
+        raise auth.translate(e, 'Play') from None
+    rows = []
+    for p in products:
+        for o in p.get('purchaseOptions', []) or [{}]:
+            rows.append({'kind': 'product', 'id': p['productId'], 'part': o.get('purchaseOptionId', ''),
+                         'state': o.get('state', ''), 'title': (p.get('listings') or [{}])[0].get('title', '')})
+    for s in subs:
+        for b in s.get('basePlans', []) or [{}]:
+            rows.append({'kind': 'subscription', 'id': s['productId'], 'part': b.get('basePlanId', ''),
+                         'state': b.get('state', ''), 'title': (s.get('listings') or [{}])[0].get('title', '')})
+    if not ctx.out.json:
+        if rows:
+            ctx.out.table([(r['kind'], r['id'], r['part'], r['state'], r['title']) for r in rows],
+                          ('kind', 'id', 'option/plan', 'state', 'title'))
+        else:
+            ctx.out.line('no products or subscriptions on Play')
+    return {'items': rows}
+
+
+def _show(out, changes):
+    if out.json:
+        return
+    if not changes:
+        out.line('  no changes: Play matches the products file', 'green')
+    for c in changes:
+        detail = ''
+        if c['kind'] == 'offer':
+            detail = _offer_detail(c)
+        elif c['kind'] == 'trial':
+            detail = {'create': f'free for {c["trial"]}, then activate',
+                      'update': f'length {c.get("from")} -> {c["trial"]}',
+                      'activate': f'state {c.get("state")} -> ACTIVE'}[c['action']]
+        elif c['action'] == 'update':
+            parts = []
+            if c['prices']:
+                parts.append('prices ' + ', '.join(f'{r} {v["from"]}->{v["to"]}' for r, v in sorted(c['prices'].items())))
+            if c['listings']:
+                parts.append('listing ' + ', '.join(c['listings']))
+            if c.get('state') != 'ACTIVE':
+                parts.append(f'state {c.get("state")} -> ACTIVE')
+            detail = '; '.join(parts)
+        out.line(f'  {c["action"]:8} {c["kind"]:12} {c["id"]}  {detail}')
+
+
+def _day(value):
+    """2026-12-31T00:00:00Z reads as 2026-12-31; any other time stays whole."""
+    if isinstance(value, str) and value.endswith('T00:00:00Z'):
+        return value[:10]
+    return value
+
+
+def _offer_detail(c):
+    window = c['body']['discountedOffer']
+    if c['action'] == 'create':
+        when = f'until {_day(window["endTime"])}'
+        if 'startTime' in window:
+            when = f'{_day(window["startTime"])} to {_day(window["endTime"])}'
+        return f'{c["discount_pct"]}% off in {c["regions"]} region(s), {when}, then activate'
+    parts = []
+    for field, v in c['changes'].items():
+        if field == 'regions':
+            parts.append(f'add region(s) {", ".join(v["added"])}')
+        elif field == 'discount_pct':
+            fix = f' (fix {", ".join(v["regions"])})' if v.get('regions') else ''
+            parts.append(f'discount {v["from"]}% -> {v["to"]}%{fix}')
+        elif field == 'tags':
+            parts.append(f'tags {v["from"]} -> {v["to"]}')
+        else:
+            parts.append(f'{field} {_day(v["from"]) or "none"} -> {_day(v["to"])}')
+    if c.get('state') != 'ACTIVE':
+        parts.append(f'state {c.get("state")} -> ACTIVE')
+    return '; '.join(parts)
+
+
+def _public(changes):
+    return [{k: v for k, v in c.items() if k != 'body'} for c in changes]
+
+
+@command('products plan', 'Compare the products file with Play (changes nothing)', risk='plan',
+         needs=('play', 'store'))
+def products_plan(ctx, args):
+    data = money.load(ctx.project)
+    svc, package = _svc(ctx)
+    try:
+        changes = money.plan(svc, package, data)
+    except Exception as e:
+        raise auth.translate(e, 'Play') from None
+    _show(ctx.out, changes)
+    if changes:
+        ctx.exit_code = DRIFT
+    return {'changes': _public(changes)}
+
+
+@command('products apply',
+         'Create or update products, their offers and subscriptions to match the file, and activate them',
+         risk='publish', needs=('play', 'store'))
+def products_apply(ctx, args):
+    data = money.load(ctx.project)
+    svc, package = _svc(ctx)
+    try:
+        changes = money.plan(svc, package, data)
+        _show(ctx.out, changes)
+        if not changes:
+            return {'changes': [], 'changed': False}
+        safety.confirm(ctx, f'Apply {len(changes)} product change(s) to {package}',
+                       [f'{c["action"]} {c["kind"]} {c["id"]}' for c in changes])
+        if ctx.dry_run:
+            return {'changes': _public(changes), 'dry_run': True}
+        money.apply(svc, package, data, changes)
+    except Exception as e:
+        raise auth.translate(e, 'Play') from None
+    if not ctx.out.json:
+        ctx.out.line(f'{len(changes)} change(s) applied and activated', 'green')
+    return {'changes': _public(changes), 'changed': True}
+
+
+@command('prices convert', "Google Play's own local price for every region, from one price",
+         risk='read', needs=('play',),
+         args=(Arg('amount', 'price, tax exclusive, e.g. 4.99', kind='positional', type=float),
+               Arg('currency', 'currency of the amount', default='USD')),
+         examples=('mkit prices convert 4.99',))
+def prices_convert(ctx, args):
+    svc, package = _svc(ctx)
+    try:
+        result = money.convert(svc, package, args.amount, args.currency)
+    except Exception as e:
+        raise auth.translate(e, 'Play') from None
+    if not ctx.out.json:
+        ctx.out.table([(r, v['currency'], v['amount']) for r, v in sorted(result.items())],
+                      ('region', 'currency', 'amount'))
+    return {'amount': args.amount, 'currency': args.currency, 'regions': result}