nowrun 2.0.0__tar.gz → 2.0.2__tar.gz

{nowrun-2.0.0 → nowrun-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nowrun
-Version: 2.0.0
+Version: 2.0.2
 Summary: CLI to deploy and manage Android and HTML5 apps on nowrun.
 Home-page: https://nowrun.io
 Author: nowrun
@@ -14,12 +14,12 @@ Description-Content-Type: text/markdown
 
 # nowrun CLI
 
-Deploy Android and HTML5 apps to a live URL - driven by your AI coding agent.
+Publish Android apps so people can run them inside ChatGPT - driven by your AI coding agent.
 
-`nowrun` publishes Android and HTML5 apps to [nowrun](https://nowrun.io) and streams each at a
-URL anyone can open in a browser, no install. You don't run deploy commands by hand: you set
-the CLI up once, then tell your agent to ship. Android works with any engine that builds an APK
-(native, Unity, Godot, Unreal); HTML5 games deploy as a zipped bundle.
+`nowrun` publishes Android apps to [nowrun](https://nowrun.io) so people can run them inside
+ChatGPT (and other AI assistants that connect to nowrun) - streamed into the conversation, no
+install and no app store. You don't run deploy commands by hand: you set the CLI up once, then
+tell your agent to ship. Works with any engine that builds an APK (native, Unity, Godot, Unreal).
 
 ## Quickstart
 
@@ -38,10 +38,10 @@ copy or paste. (`nowrun update` refreshes it later; `nowrun logout` signs out.)
 
 **3. Tell your agent.** Open your AI coding tool in your project and give it this prompt:
 
-> Deploy my app to nowrun and give me the live public URL using the nowrun CLI. If you need the steps, read https://nowrun.io/docs/skill.md
+> Deploy my app to nowrun so people can run it in ChatGPT using the nowrun CLI. If you need the steps, read https://nowrun.io/docs/skill.md
 
-Your agent creates (or reuses) the app, uploads the build, deploys it, and hands back the live
-URL. That's the whole flow.
+Your agent creates (or reuses) the app, uploads the build, and deploys it - and once it's live,
+people can run it inside ChatGPT. That's the whole flow.
 
 ## What your agent runs for you
 
@@ -56,13 +56,14 @@ They're here for reference (and the occasional manual run):
 | `nowrun app list` / `nowrun app show` | list your apps / show one, with its visibility and readiness |
 | `nowrun inspect app.apk` | read a build's package + version, no Android SDK needed |
 | `nowrun validate` | check what's missing before deploying |
-| `nowrun deploy -f app.apk` | deploy a build and get its live link (version read from the APK; `--wait` blocks until live) |
+| `nowrun deploy -f app.apk` | deploy a build so it's runnable in ChatGPT (version read from the APK; `--wait` blocks until live) |
 | `nowrun status -s <submission_id>` | poll until it's live |
 | `nowrun help --json` | full command list + workflow (what the agent reads) |
 
 `deploy` reads the build's package/version and **refuses to deploy a build whose package
-doesn't match the app**, so you never publish to the wrong place. Add `--json` (in any
-position) to any command for machine-readable output.
+doesn't match the app**, so you never publish to the wrong place. It also **refuses a version
+code that isn't higher than the one currently live** (like the Play Store), so you can't ship a
+downgrade. Add `--json` (in any position) to any command for machine-readable output.
 
 New apps are private; a nowrun admin decides which deployed apps are listed in ChatGPT.
 You stay signed in: the CLI refreshes its session automatically (for 30 days after last use).

{nowrun-2.0.0 → nowrun-2.0.2}/README.md

@@ -1,11 +1,11 @@
 # nowrun CLI
 
-Deploy Android and HTML5 apps to a live URL - driven by your AI coding agent.
+Publish Android apps so people can run them inside ChatGPT - driven by your AI coding agent.
 
-`nowrun` publishes Android and HTML5 apps to [nowrun](https://nowrun.io) and streams each at a
-URL anyone can open in a browser, no install. You don't run deploy commands by hand: you set
-the CLI up once, then tell your agent to ship. Android works with any engine that builds an APK
-(native, Unity, Godot, Unreal); HTML5 games deploy as a zipped bundle.
+`nowrun` publishes Android apps to [nowrun](https://nowrun.io) so people can run them inside
+ChatGPT (and other AI assistants that connect to nowrun) - streamed into the conversation, no
+install and no app store. You don't run deploy commands by hand: you set the CLI up once, then
+tell your agent to ship. Works with any engine that builds an APK (native, Unity, Godot, Unreal).
 
 ## Quickstart
 
@@ -24,10 +24,10 @@ copy or paste. (`nowrun update` refreshes it later; `nowrun logout` signs out.)
 
 **3. Tell your agent.** Open your AI coding tool in your project and give it this prompt:
 
-> Deploy my app to nowrun and give me the live public URL using the nowrun CLI. If you need the steps, read https://nowrun.io/docs/skill.md
+> Deploy my app to nowrun so people can run it in ChatGPT using the nowrun CLI. If you need the steps, read https://nowrun.io/docs/skill.md
 
-Your agent creates (or reuses) the app, uploads the build, deploys it, and hands back the live
-URL. That's the whole flow.
+Your agent creates (or reuses) the app, uploads the build, and deploys it - and once it's live,
+people can run it inside ChatGPT. That's the whole flow.
 
 ## What your agent runs for you
 
@@ -42,13 +42,14 @@ They're here for reference (and the occasional manual run):
 | `nowrun app list` / `nowrun app show` | list your apps / show one, with its visibility and readiness |
 | `nowrun inspect app.apk` | read a build's package + version, no Android SDK needed |
 | `nowrun validate` | check what's missing before deploying |
-| `nowrun deploy -f app.apk` | deploy a build and get its live link (version read from the APK; `--wait` blocks until live) |
+| `nowrun deploy -f app.apk` | deploy a build so it's runnable in ChatGPT (version read from the APK; `--wait` blocks until live) |
 | `nowrun status -s <submission_id>` | poll until it's live |
 | `nowrun help --json` | full command list + workflow (what the agent reads) |
 
 `deploy` reads the build's package/version and **refuses to deploy a build whose package
-doesn't match the app**, so you never publish to the wrong place. Add `--json` (in any
-position) to any command for machine-readable output.
+doesn't match the app**, so you never publish to the wrong place. It also **refuses a version
+code that isn't higher than the one currently live** (like the Play Store), so you can't ship a
+downgrade. Add `--json` (in any position) to any command for machine-readable output.
 
 New apps are private; a nowrun admin decides which deployed apps are listed in ChatGPT.
 You stay signed in: the CLI refreshes its session automatically (for 30 days after last use).

{nowrun-2.0.0 → nowrun-2.0.2}/nowrun/cli.py

@@ -57,7 +57,7 @@ WORKFLOW = [
     "app create --title <t> ...   # create an app with all its metadata (or 'app list' to reuse one)",
     "use <app_id>                # bind this workspace to an app (optional)",
     "validate                     # check what's missing before deploying",
-    "deploy -f app.apk ...        # upload + deploy a build and get the live link",
+    "deploy -f app.apk ...        # upload + deploy a build (runnable in ChatGPT once live)",
     "status                       # poll until it's live",
     "mode [admin|personal]        # nowrun admins: show/switch mode (admin = nowrun-managed apps, audited)",
     "admin apps list ...          # nowrun admins (admin mode): review apps, set-public/disable/..., users, audit",
@@ -112,8 +112,9 @@ def build_manifest(parser):
     tree = _describe(parser, 'nowrun', 'nowrun publishing CLI')
     return {
         "tool": "nowrun",
-        "description": "Deploy Android and HTML5 apps to nowrun. Sign in once with `nowrun login`. "
-                       "Every command supports --json for machine-readable output.",
+        "description": "Deploy Android apps to nowrun so people can run them inside ChatGPT. "
+                       "Sign in once with `nowrun login`. Every command supports --json for "
+                       "machine-readable output.",
         "workflow": WORKFLOW,
         "commands": tree.get("subcommands", []),
         "global_options": tree.get("args", []),
@@ -248,7 +249,7 @@ def build_parser():
                     'flags override it. In admin mode this creates a nowrun-managed app.')
     app_create_parser.add_argument('-t', '--title', type=str, help='App title (required)')
     app_create_parser.add_argument('--type', dest='game_type', choices=['android', 'h5'],
-                                   help='App type: android (default) or h5 (HTML5 web game)')
+                                   help='App type (default: android)')
     app_create_parser.add_argument('-p', '--package', dest='app_pkg_name', type=str,
                                    help='Android package name (required for --type android; or use --from-apk)')
     app_create_parser.add_argument('-f', '--from-apk', dest='from_apk', type=str,
@@ -279,24 +280,29 @@ def build_parser():
     app_delete_parser.add_argument('-y', '--yes', action='store_true', help='Skip the confirmation prompt (for scripts/agents)')
 
     # deploy
-    deploy_parser = subparsers.add_parser('deploy', help='Deploy a build and get its live link', formatter_class=fmt)
+    deploy_parser = subparsers.add_parser('deploy', help='Deploy a build (runnable in ChatGPT once live)', formatter_class=fmt)
     deploy_parser.add_argument('-a', '--app-id', '--app_id', dest='app_id', type=str, help="The app's app_id from `app create` / `app list` (default: workspace app)", required=False)
     deploy_parser.add_argument('-f', '--file_path', type=str,
-                               help='Path to the build: an .apk/.zip for Android, or a .zip web bundle for HTML5',
+                               help='Path to the build: an .apk or .zip for Android',
                                required=True)
     deploy_parser.add_argument('-av', '--apk_version', type=str,
                                help='Version name (Android; auto-read from the .apk if omitted)', required=False)
     deploy_parser.add_argument('-vc', '--version_code', type=int,
                                help='Version code (Android; auto-read from the .apk if omitted)', required=False)
     deploy_parser.add_argument('--wait', action='store_true',
-                               help='Block until the deployment is live (or fails) and print the live URL')
+                               help='Block until the deployment is live (or fails)')
     deploy_parser.add_argument('--timeout', type=int, default=900,
                                help='With --wait, give up after this many seconds (default: 900)')
 
     # status
-    status_parser = subparsers.add_parser('status', help='Check deployment/job status', formatter_class=fmt)
+    status_parser = subparsers.add_parser('status', help='Show what is live and in progress, or one submission with -s', formatter_class=fmt)
     status_parser.add_argument('-a', '--app-id', '--app_id', dest='app_id', type=str, help="The app's app_id from `app create` / `app list` (default: workspace app)", required=False)
-    status_parser.add_argument('-s', '--submission_id', type=str, help='Submission ID (from deploy)', required=True)
+    status_parser.add_argument('-s', '--submission_id', type=str, help='A specific submission (from deploy); omit for the deployment overview', required=False)
+
+    # cancel
+    cancel_parser = subparsers.add_parser('cancel', help='Cancel the deployment in progress for an app', formatter_class=fmt)
+    cancel_parser.add_argument('-a', '--app-id', '--app_id', dest='app_id', type=str, help="The app's app_id from `app create` / `app list` (default: workspace app)", required=False)
+    cancel_parser.add_argument('-s', '--submission_id', type=str, help='A specific in-progress submission to cancel (default: the app\'s current one)', required=False)
 
     # validate (publish-readiness)
     validate_parser = subparsers.add_parser('validate', help='Check publish-readiness of an app', formatter_class=fmt)
@@ -373,7 +379,7 @@ def _admin_parsers(subparsers):
         'set-private': 'Remove apps from the catalog listing',
         'disable': 'Disable apps: out of the catalog, read-only, no deploys (asks to confirm)',
         'enable': 'Re-enable disabled apps',
-        'unpublish': 'Take the live deployment down (private, live URL cleared; asks to confirm)',
+        'unpublish': 'Take the live deployment down (private; removed from ChatGPT; asks to confirm)',
         'remove': 'Remove any apps: out of every list and the catalog, package freed, record kept (asks to confirm)',
         'delete': 'PERMANENTLY erase nowrun-managed apps and their builds - cannot be undone (asks to confirm)',
     }
@@ -384,14 +390,16 @@ def _admin_parsers(subparsers):
         p.add_argument('-y', '--yes', action='store_true', help='Skip the confirmation prompt')
 
     fetch = apps_sub.add_parser(
-        'fetch-apk', help='Download an APK from a link into the deploy bucket (does not deploy)',
+        'fetch-apk', help='Download a build from a link to this machine and report it (does not deploy)',
         formatter_class=fmt,
-        description="Download an APK from a link server-side and report what it is (package, "
-                    "version, size, SHA-256). The build is an untrusted third-party one: it is "
-                    "staged, not deployed, until you review it and pass --deploy.")
+        description="Download an APK/ZIP from a link onto this machine, read its metadata "
+                    "locally (package, version, size, SHA-256), and report it. The download and, "
+                    "on --deploy, the upload run from here, not through nowrun's servers. The "
+                    "build is an untrusted third-party one: it is not deployed until you review "
+                    "it and pass --deploy, which deploys it via the normal upload flow.")
     fetch.add_argument('-a', '--app-id', '--app_id', dest='app_id', type=str,
                        help="The app to provision (default: workspace app)", required=False)
-    fetch.add_argument('--url', type=str, required=True, help='Direct http(s) link to the .apk')
+    fetch.add_argument('--url', type=str, required=True, help='Direct http(s) link to the .apk or .zip')
     fetch.add_argument('--expected-package', dest='expected_package', type=str,
                        help='Fail unless the fetched build has this package name')
     fetch.add_argument('--deploy', action='store_true',
@@ -518,8 +526,8 @@ def main():
                 "publisher tokens are no longer used - ignoring -t/--token and signing in with "
                 "`nowrun login` (browser). Update this command to `nowrun login`.")
         # login is strict about the target environment: with --host, use it; WITHOUT --host,
-        # always reset to prod - never inherit a host left over from an earlier `--host qa1`
-        # (which would silently sign you into the wrong environment).
+        # always reset to prod - never inherit a host left over from an earlier
+        # `--host https://qa.nowrun.io` (which would silently sign you into the wrong environment).
         if getattr(args, 'host', None):
             config.set_host(config.resolve_host(args.host))
         else:
@@ -598,7 +606,14 @@ def main():
     elif args.command == 'status':
         app_id = resolve_app_id(args)
         if app_id:
-            deploy_cmd.status(app_id, args.submission_id)
+            if args.submission_id:
+                deploy_cmd.status(app_id, args.submission_id)
+            else:
+                deploy_cmd.deployment_overview(app_id)
+    elif args.command == 'cancel':
+        app_id = resolve_app_id(args)
+        if app_id:
+            deploy_cmd.cancel(app_id, args.submission_id)
     elif args.command == 'validate':
         app_id = resolve_app_id(args)
         if app_id:

{nowrun-2.0.0 → nowrun-2.0.2}/nowrun/commands/admin.py

@@ -6,8 +6,15 @@ suspend|reactivate; audit. All under /v2/admin/*, which the server refuses outsi
 is given before any request. Every change is audited server-side, one entry per item.
 """
 import datetime
+import hashlib
+import os
 import sys
+import tempfile
+import urllib.parse
 
+import requests
+
+from nowrun import apk
 from nowrun import config
 from nowrun import fields as fieldmap
 from nowrun import output
@@ -60,10 +67,6 @@ def require_admin_mode():
     return False
 
 
-def _error_code(body):
-    return (body.get('error_code') or body.get('code')) if isinstance(body, dict) else None
-
-
 def _bool_param(value):
     return None if value is None else ('true' if value else 'false')
 
@@ -257,62 +260,136 @@ def apps_action(command, app_ids, reason=None, assume_yes=False):
     _bulk('/v2/admin/apps/bulk', 'app_ids', app_ids, action, reason, 'app')
 
 
-# --- apk sourcing (provision an app from a link) --------------------------------------
+# --- apk sourcing (download a build from a link and deploy it from this machine) -------
+
+# Streamed and capped so a bad link cannot fill the disk; matches the size the deploy
+# pipeline accepts.
+_MAX_APK_BYTES = 400 * 1024 * 1024
+_DOWNLOAD_TIMEOUT = 120
+_TOO_LARGE = "That build is larger than nowrun allows (400 MB)."
+
 
 def fetch_apk(app_id, url, expected_package=None, deploy=False, assume_yes=False,
               wait=False, timeout=900):
-    """Download an APK from a link into the deploy bucket (server-side) and report what it is.
-    With deploy=True, deploy it after confirming; otherwise stage it and tell the user to
-    review and deploy."""
+    """Download an APK/ZIP from a link ON THIS MACHINE, read its metadata locally, and - with
+    --deploy - deploy it through the normal upload flow (the same path as `nowrun deploy -f`).
+
+    The build is fetched and uploaded from here, not routed through nowrun's servers: a local
+    machine is faster for the download + upload, and the metadata is read locally rather than by
+    the backend."""
     if not require_admin_mode():
         return
-    body = {"app_id": app_id, "url": url}
-    if expected_package:
-        body["expected_package"] = expected_package
-    ok, resp, status = StudioClient().request('POST', '/v2/admin/apps/fetch-apk', json_body=body)
-    if not ok:
-        _fetch_apk_error(resp, status)
-        return
-    data = resp.get('data') or {}
-    if deploy and not data.get('package_matches', True):
-        # A build whose package doesn't match would deploy to the wrong app.
-        emit_error(f"The fetched build's package '{data.get('package')}' does not match this app.",
-                   code='PACKAGE_MISMATCH',
-                   hint="Fetch the right build, or omit --deploy to stage and review it first.")
-        return
-    if not deploy:
-        emit_success({**data, "staged": True, "deployed": False}, human=_print_fetched)
+    if urllib.parse.urlparse(url).scheme not in ("http", "https"):
+        emit_error("The build link must be an http(s) URL.", code="INVALID_URL",
+                   hint="Pass a direct link to an .apk or .zip.")
         return
 
-    if not _confirm_fetch_deploy(app_id, data, assume_yes):
-        return
-    from nowrun.commands import deploy as deploy_cmd
     if not output.is_json():
-        _print_fetched(data)
-    deploy_cmd.deploy_staged(app_id, data.get('upload_url'), data.get('upload_type'),
-                             version=data.get('version_name'), version_code=data.get('version_code'),
-                             wait=wait, timeout=timeout)
+        logger.info(color("Downloading the build to this machine…", 'dim'))
+    path, err = _download_build(url)
+    if err:
+        emit_error(err[0], code=err[1], hint=err[2])
+        return
+    try:
+        meta = apk.inspect(path)  # local read: package, version_name, version_code
+        package = meta.get("package")
+        if expected_package and package and package != expected_package:
+            emit_error(f"The build is '{package}', not '{expected_package}'.",
+                       code="PACKAGE_MISMATCH",
+                       hint="Fetch the build whose package matches, or drop --expected-package.")
+            return
+        data = {"package": package, "version_name": meta.get("version_name"),
+                "version_code": meta.get("version_code"), "size": os.path.getsize(path),
+                "sha256": _sha256_file(path), "deployed": bool(deploy)}
+        if not deploy:
+            emit_success(data, human=_print_fetched)
+            return
+        if not _confirm_fetch_deploy(app_id, data, assume_yes):
+            return
+        from nowrun.commands import deploy as deploy_cmd
+        if not output.is_json():
+            _print_fetched(data)
+        # Deploy via the normal local upload path (multipart upload + trigger), exactly like
+        # `nowrun deploy -f`: it re-reads the package/version from the file and refuses a build
+        # whose package does not match the bound app.
+        deploy_cmd.deploy(app_id, path, meta.get("version_name"), meta.get("version_code"),
+                          wait=wait, timeout=timeout)
+    finally:
+        _safe_remove(path)
+
+
+def _download_build(url):
+    """Stream a build to a temp file on this machine. Returns (path, None) on success, or
+    (None, (message, code, hint)) on failure."""
+    # Keep the extension so apk.inspect() and deploy() route .zip vs .apk correctly.
+    suffix = ".zip" if urllib.parse.urlparse(url).path.lower().endswith(".zip") else ".apk"
+    tmp = tempfile.NamedTemporaryFile(prefix="nowrun-fetch-", suffix=suffix, delete=False)
+    path = tmp.name
+    total = 0
+    try:
+        with requests.get(url, stream=True, timeout=_DOWNLOAD_TIMEOUT,
+                          allow_redirects=True) as resp:
+            if resp.status_code != 200:
+                tmp.close(); _safe_remove(path)
+                return None, (f"The link returned HTTP {resp.status_code}.", "FETCH_FAILED",
+                              "Check the link and retry.")
+            declared = int(resp.headers.get("content-length") or 0)
+            if declared and declared > _MAX_APK_BYTES:
+                tmp.close(); _safe_remove(path)
+                return None, (_TOO_LARGE, "APK_TOO_LARGE", None)
+            for chunk in resp.iter_content(chunk_size=256 * 1024):
+                if not chunk:
+                    continue
+                total += len(chunk)
+                if total > _MAX_APK_BYTES:
+                    tmp.close(); _safe_remove(path)
+                    return None, (_TOO_LARGE, "APK_TOO_LARGE", None)
+                tmp.write(chunk)
+        tmp.close()
+        return path, None
+    except requests.Timeout:
+        tmp.close(); _safe_remove(path)
+        return None, ("The download timed out.", "FETCH_TIMEOUT", "Try a faster or direct link.")
+    except requests.RequestException as exc:
+        tmp.close(); _safe_remove(path)
+        return None, (f"Could not download the build: {exc}", "FETCH_FAILED",
+                      "Check the link and retry.")
+
+
+def _sha256_file(path):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(1024 * 1024), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def _safe_remove(path):
+    try:
+        os.remove(path)
+    except OSError:
+        pass
 
 
 def _print_fetched(d):
-    logger.info(color("Fetched an unreviewed third-party build. Review it before deploying.", 'yellow'))
-    logger.info(f"Package     : {d.get('package', '')}"
-                + ("" if d.get('package_matches', True) else color("  (does NOT match the app!)", 'red')))
+    logger.info(color("Downloaded an unreviewed third-party build to this machine. "
+                      "Review it before deploying.", 'yellow'))
+    logger.info(f"Package     : {d.get('package', '')}")
     logger.info(f"Version     : {d.get('version_name', '')} (code {d.get('version_code', '')})")
     size = d.get('size')
     if size:
         logger.info(f"Size        : {round(int(size) / (1024 * 1024), 2)} MB")
     logger.info(f"SHA-256     : {d.get('sha256', '')}")
-    if not d.get('deployed', True) and d.get('staged'):
-        logger.info(color("Staged, not deployed. Deploy it with: "
-                          "nowrun admin apps fetch-apk -a <app_id> --url <same url> --deploy", 'dim'))
+    if not d.get('deployed', True):
+        logger.info(color("Not deployed. Deploy it with: nowrun admin apps fetch-apk "
+                          "-a <app_id> --url <same url> --deploy", 'dim'))
 
 
 def _confirm_fetch_deploy(app_id, data, assume_yes):
     if assume_yes:
         return True
     if sys.stdin.isatty() and not output.is_json():
-        logger.info(color(f"[ADMIN MODE] Deploy the fetched build '{data.get('package')}' "
+        logger.info(color(f"[ADMIN MODE] Deploy the downloaded build '{data.get('package')}' "
                           f"v{data.get('version_name')} to {app_id}? It is an unreviewed "
                           "third-party build. This is audited.", 'yellow'))
         try:
@@ -321,42 +398,14 @@ def _confirm_fetch_deploy(app_id, data, assume_yes):
             resp = ''
         if resp.strip().lower() == 'yes':
             return True
-        emit_error("Aborted - the build is staged but not deployed.", code='ABORTED')
+        emit_error("Aborted - the build was downloaded but not deployed.", code='ABORTED')
         return False
     emit_error(f"Refusing to deploy an unreviewed build to {app_id} without confirmation.",
                code='CONFIRMATION_REQUIRED',
-               hint="Re-run with --yes to confirm, or omit --deploy to stage and review first.")
+               hint="Re-run with --yes to confirm, or omit --deploy to download and review first.")
     return False
 
 
-_FETCH_APK_GUIDANCE = {
-    'NOT_AN_APK': "The link did not point to a valid Android APK. Use a direct link to an .apk file.",
-    'INVALID_URL': "The URL is not valid. Pass a direct http(s) link to the build.",
-    'FETCH_FAILED': "nowrun couldn't download the build from that link. Check the link and retry.",
-    'FETCH_TIMEOUT': "The download timed out. Try a faster mirror or a direct link.",
-    'APK_TOO_LARGE': "The build is larger than nowrun allows. Use a smaller build.",
-}
-
-
-def _fetch_apk_error(body, status):
-    code = _error_code(body)
-    if code == 'PACKAGE_MISMATCH':
-        fetched = ((body.get('details') or {}).get('fetched_package')
-                   if isinstance(body, dict) else None)
-        got = f" (got '{fetched}')" if fetched else ""
-        emit_error(f"The fetched build's package doesn't match --expected-package{got}.",
-                   http_status=status, code=code,
-                   hint="Fetch the build whose package matches, or drop --expected-package to "
-                        "stage it anyway and review.")
-        return
-    hint = _FETCH_APK_GUIDANCE.get(code)
-    if hint:
-        message = body.get('message') if isinstance(body, dict) else None
-        emit_error(message or hint, http_status=status, code=code, hint=hint)
-        return
-    api_error(body, status, fallback='Failed to fetch the APK')
-
-
 # --- users ----------------------------------------------------------------------------
 
 def users_list(email=None, status=None, created_from=None, created_to=None, limit=None,

{nowrun-2.0.0 → nowrun-2.0.2}/nowrun/commands/deploy.py

@@ -146,29 +146,6 @@ def trigger_deploy(app_id, upload_url, upload_type, version=None, version_code=N
         })
 
 
-def deploy_staged(app_id, upload_url, upload_type, version=None, version_code=None, wait=False,
-                  timeout=900):
-    """Deploy a build that was already staged into the bucket (e.g. by fetch-apk), then report
-    the submission the same way `deploy` does. Emits its own error on failure."""
-    ok, body, status = trigger_deploy(app_id, upload_url, upload_type, version, version_code)
-    if not ok:
-        api_error(body, status, fallback='Deployment failed')
-        return
-    submission = body.get('data', {}) or {}
-    submission_id = submission.get('id')
-    if wait and submission_id:
-        _wait_until_done(app_id, submission_id, timeout, [])
-        return
-    result = {"submission_id": submission_id,
-              "submission_state": submission.get('submission_state'),
-              "job_status": submission.get('job_status')}
-
-    def _triggered(d):
-        logger.info(f"Deploy started for {scope_label()} {app_id} (submission {d['submission_id']}).")
-        logger.info(color(f"  Check back: nowrun status -a {app_id} -s {d['submission_id']}", 'dim'))
-    emit_success(result, human=_triggered)
-
-
 def _fetch_status(app_id, submission_id):
     return StudioClient().request(
         'GET', '/v2/console/app/jenkins_job_status',
@@ -242,6 +219,73 @@ def _wait_until_done(app_id, submission_id, timeout, notes):
                         f"nowrun status -a {app_id} -s {submission_id}")
 
 
+def cancel(app_id, submission_id=None):
+    """Cancel the deployment in progress for an app so another can be started. Optional
+    submission_id targets a specific build; otherwise the app's current in-progress one."""
+    params = {'app_id': app_id}
+    if submission_id:
+        params['submission_id'] = submission_id
+    ok, body, http_status = StudioClient().request(
+        'POST', '/v2/console/app/deploy/cancel', params=params)
+    if not ok:
+        api_error(body, http_status, fallback='Failed to cancel the deployment')
+        return
+    data = body.get('data', {}) or {}
+    result = {"submission_id": data.get('id'), "job_status": data.get('job_status')}
+
+    def _done(d):
+        logger.info(color(f"✓ Cancelled the deployment for {scope_label()} {app_id}.", 'yellow'))
+        logger.info(color("  Start a new one when ready: nowrun deploy -f <build>", 'dim'))
+    emit_success(result, human=_done)
+
+
+def deployment_overview(app_id):
+    """Show what is live and what is building for an app: the live version, any in-progress
+    build, and recent deployment history - the same view as the dashboard's deploy panel."""
+    ok, body, http_status = StudioClient().request(
+        'GET', '/v2/console/app/deploy/status', params={'app_id': app_id})
+    if not ok:
+        api_error(body, http_status, fallback='Failed to fetch deployment status')
+        return
+    data = body.get('data', {}) or {}
+
+    def _print(d):
+        live = d.get('live') or {}
+        active = d.get('active')
+        recent = d.get('recent') or []
+        # Live
+        if live.get('url'):
+            vc = live.get('version_code')
+            head = f"● Live: v{vc}" if vc is not None else "● Live"
+            logger.info(color(head, 'green'))
+            logger.info(f"  {live.get('url')}")
+            if live.get('published_at'):
+                logger.info(color(f"  since {live.get('published_at')}", 'dim'))
+        else:
+            logger.info(color("● Live: not deployed yet", 'dim'))
+        # In progress
+        if active:
+            vc = active.get('app_version_code')
+            ver = f"v{vc}" if vc is not None else (active.get('app_version') or '?')
+            logger.info(color(f"⠿ In progress: {ver} ({active.get('job_status')})", 'cyan'))
+            logger.info(color(
+                f"  submission {active.get('submission_id')}"
+                + (f" · started {active.get('triggered_at')}" if active.get('triggered_at') else ""),
+                'dim'))
+            logger.info(color(f"  Cancel: nowrun cancel -a {app_id}", 'dim'))
+        # Recent history
+        if recent:
+            glyphs = {'success': '✓', 'failed': '✗', 'cancelled': '∅', 'progress': '⠿'}
+            logger.info("Recent:")
+            for s in recent[:5]:
+                vc = s.get('app_version_code')
+                ver = f"v{vc}" if vc is not None else (s.get('app_version') or '-')
+                glyph = glyphs.get(s.get('job_status'), '·')
+                created = s.get('created_at') or ''
+                logger.info(f"  {glyph} {ver:<8} {str(s.get('job_status') or ''):<9} {created}")
+    emit_success(data, human=_print)
+
+
 def status(app_id, submission_id):
     """Fetch the test-link / cloud build job status for a submission."""
     ok, body, http_status = _fetch_status(app_id, submission_id)

{nowrun-2.0.0 → nowrun-2.0.2}/nowrun/commands/inspect.py

@@ -18,8 +18,7 @@ def inspect(path):
     if not meta or not meta.get("package"):
         emit_error(
             "Could not read Android metadata from this file.",
-            hint="Pass an .apk, or an Android .zip that contains one. HTML5 .zip web "
-                 "bundles have no Android manifest, so there's nothing to read.")
+            hint="Pass an .apk, or an Android .zip that contains one.")
         return
     emit_success(meta, human=_print_inspect)
 

{nowrun-2.0.0 → nowrun-2.0.2}/nowrun/config.py

@@ -29,27 +29,17 @@ WORKSPACE_FILE = 'nowrun.json'   # per-project app binding (stays in the cwd)
 
 # nowrun-backend topology: the API is served at DOMAIN/api, the dashboard at DOMAIN/console.
 PROD_HOST = 'https://nowrun.io/api'
-QA_HOST = 'https://qa.nowrun.io/api'
-DEV_HOST = 'https://dev.nowrun.io/api'
 LOCAL_HOST = 'http://localhost:3000/api'
 
 # Default to prod. Point at another environment with the internal `--host` flag
-# (`nowrun login --host qa`), which accepts a shorthand below or a full URL.
+# (`nowrun login --host https://qa.nowrun.io`), which takes a full URL or a bare host -
+# there are no named shorthands. See resolve_host.
 DEFAULT_HOST = PROD_HOST
 
-# Shorthand -> API host, and API host -> console (dashboard) URL where `nowrun login`
-# opens the browser. prod -> nowrun.io, qa / qa1 -> qa.nowrun.io, dev -> dev.nowrun.io.
-_HOST_ALIASES = {
-    'prod': PROD_HOST,
-    'qa': QA_HOST,
-    'qa1': QA_HOST,
-    'dev': DEV_HOST,
-    'local': LOCAL_HOST,
-}
+# API host -> console (dashboard) URL where `nowrun login` opens the browser. Only the
+# exceptions live here: local serves its dashboard on a different port. Every other
+# host's console is DOMAIN/console, derived in console_url().
 _CONSOLE_URLS = {
-    PROD_HOST: 'https://nowrun.io/console',
-    QA_HOST: 'https://qa.nowrun.io/console',
-    DEV_HOST: 'https://dev.nowrun.io/console',
     LOCAL_HOST: 'http://localhost:3002',
 }
 
@@ -86,12 +76,26 @@ def ui_host():
 
 
 def resolve_host(value):
-    """Map a --host value to a full API host URL. Accepts a full URL, or a shorthand
-    (prod / qa / qa1 / dev / local). Returns None for an empty value."""
+    """Map a --host value to a full API host URL. Takes a full URL
+    ("https://qa.nowrun.io") or a bare host ("qa.nowrun.io", "localhost:3000") -
+    there are no named shorthands. Returns None for an empty value.
+
+    The API lives at DOMAIN/api and the client appends API paths (/v2/...) to the
+    host verbatim, so the resolved host MUST end in /api - otherwise every call
+    hits the wrong path and auth looks broken. So we normalise: add a scheme for a
+    bare host (http for localhost, else https), then the /api suffix if missing.
+    """
     if not value:
         return None
-    v = value.strip()
-    return _HOST_ALIASES.get(v.lower(), v)
+    v = value.strip().rstrip('/')
+    if not v:
+        return None
+    if not (v.startswith('http://') or v.startswith('https://')):
+        scheme = 'http' if v.split(':', 1)[0] in ('localhost', '127.0.0.1') else 'https'
+        v = f'{scheme}://{v}'
+    if not v.endswith('/api'):
+        v = f'{v}/api'
+    return v
 
 
 def _cache_obj():

{nowrun-2.0.0 → nowrun-2.0.2}/nowrun/output.py

@@ -301,6 +301,12 @@ _CODE_GUIDANCE = {
     'BULK_PARTIAL_FAILURE': (
         "Some items in the batch failed.",
         "See each item's error_code/message in `detail.results`; fix those and retry only the failed ids."),
+    'DEPLOY_IN_PROGRESS': (
+        "A deployment is already in progress for this app, so another can't start yet.",
+        "Watch it with `nowrun status`; to replace it, cancel first with `nowrun cancel`, then deploy again."),
+    'NO_DEPLOY_IN_PROGRESS': (
+        "There's no deployment in progress for this app to cancel.",
+        "Check the current state with `nowrun status`."),
 }
 
 

{nowrun-2.0.0 → nowrun-2.0.2}/nowrun/skill/SKILL.md

@@ -1,14 +1,14 @@
 ---
 name: nowrun-publishing
-description: Deploy and manage Android and HTML5 (web) apps on nowrun using the `nowrun` CLI. Use whenever the user wants to create an app, upload a build, deploy it to a live link, check status/readiness, or update its listing metadata.
+description: Deploy and manage Android apps on nowrun using the `nowrun` CLI. Use whenever the user wants to create an app, upload a build, deploy it so people can run it in ChatGPT, check status/readiness, or update its listing metadata.
 ---
 
 # Publishing to nowrun with the `nowrun` CLI
 
-The `nowrun` CLI deploys **Android** apps (compiled `.apk`/`.zip`) and **HTML5** web
-games (a `.zip` web bundle) to nowrun. The human signs in once with `nowrun login`
-(browser); you operate the CLI, and the human handles account setup and app configuration
-in the dashboard.
+The `nowrun` CLI deploys **Android** apps (a compiled `.apk`, or an `.apk` inside a `.zip`)
+to nowrun, so people can run them inside ChatGPT (and other AI assistants that connect to
+nowrun). The human signs in once with `nowrun login` (browser); you operate the CLI, and the
+human handles account setup and app configuration in the dashboard.
 
 ## First: discover the tool (don't guess commands)
 
@@ -85,7 +85,9 @@ Follow this sequence end to end; each step is expanded in the sections below.
    the flag that sets it). For Android, also verify the binary (package matches,
    release-signed) - see "Android builds" below.
 5. **Deploy** - `nowrun deploy -f <build> [-av <name> -vc <code>]`, then poll
-   `nowrun status -s <submission_id>` until it returns the live URL. Share the URL.
+   `nowrun status -s <submission_id>` until it goes live (or pass `--wait`). Once live, the
+   app is runnable in ChatGPT. `nowrun status` (no `-s`) shows what's live and what's building;
+   `nowrun cancel` stops a build in progress so you can start another.
 6. **Delete (end of life)** - `nowrun app delete -a <app_id> --yes` permanently removes the
    app and frees a plan app slot. Destructive and irreversible: only on an explicit user
    request, and confirm the exact `app_id` first.
@@ -104,12 +106,9 @@ nowrun app list --json     # otherwise find an existing app whose app_pkg_name m
   `nowrun use <app_id>` (writes nowrun.json).
 - **No match:** create it with all its metadata (see "App metadata" below); this
   **auto-binds** (writes nowrun.json):
-  - **Android:** `nowrun app create --title "My App" -p com.foo.bar ...` (or
-    `--from-apk app.apk` to read the package name - and, without `--icon`, the launcher
-    icon - straight from the build instead of `-p`).
-  - **HTML5:** `nowrun app create --title "My Game" --type h5 ...` - no package; it is
-    synthesized. (HTML5 apps won't appear in `app list` by package, so reuse the `app_id`
-    from nowrun.json / `app list` rather than matching a package name.)
+  `nowrun app create --title "My App" -p com.foo.bar ...` (or `--from-apk app.apk` to read
+  the package name - and, without `--icon`, the launcher icon - straight from the build
+  instead of `-p`).
 
 After this, `nowrun.json` holds the app_id and `deploy`/`status`/`validate` default to it.
 Never run `app create` for a package that already has an app.
@@ -176,25 +175,33 @@ human; only a nowrun admin can re-enable it.
   out of an Android build. `validate` flags a missing icon; set one before deploying so the
   live app looks complete. (`--from-apk` is best-effort - if the build has no resolvable
   raster icon it tells you, and you provide an image instead.)
-- **Deploy:**
-  - **Android:** `nowrun deploy -f app.apk` - the version name and code are read from the
-    APK automatically. Pass `-av <name> -vc <code>` only to override; if they disagree with
-    the APK the CLI warns you. First verify the binary (see "Android builds" below).
-  - **HTML5:** `nowrun deploy -f game.zip` (a web bundle; no version name/code - HTML5 has none).
-
-  Uploads the build and deploys it, then poll `nowrun status -s <submission_id>` until it
-  returns a live URL. Share the URL. Add `--wait` to have `deploy` block and return the live
-  URL itself (no polling loop needed).
+- **Deploy:** `nowrun deploy -f app.apk` - the version name and code are read from the APK
+  automatically. Pass `-av <name> -vc <code>` only to override; if they disagree with the APK
+  the CLI warns you. First verify the binary (see "Android builds" below). The version code must
+  be higher than the currently live one (like the Play Store) or the deploy is rejected.
+
+  Uploads the build and deploys it, then poll `nowrun status -s <submission_id>` until it goes
+  live; once live, the app is runnable in ChatGPT. Add `--wait` to have `deploy` block until it
+  settles (no polling loop needed).
   If deploy fails with error code `CARD_NOT_VERIFIED` (HTTP 402), the human hasn't
   verified a payment card yet - tell them to add one in the nowrun dashboard (the error
   message includes the link), then retry. This is required only once, before the first deploy.
+- **See what's deployed / building:** `nowrun status` (no `-s`) shows the current live
+  version and URL, any build in progress, and recent deployment history for the app - the same
+  view as the dashboard's deploy panel. Use `nowrun status -s <submission_id>` to check one
+  specific submission.
+- **Cancel a deployment:** `nowrun cancel` stops the build in progress for the app so you can
+  start a new one (there's only one deployment per app at a time). Only one build can run at a
+  time: if a deploy fails with `DEPLOY_IN_PROGRESS` (HTTP 429), either wait/poll `nowrun status`
+  or `nowrun cancel` first, then deploy again. `NO_DEPLOY_IN_PROGRESS` means nothing was running
+  to cancel. A cancelled build won't go live even if its cloud job later finishes.
 
 ## Android builds: verify the binary before you deploy
 
 `nowrun validate` covers the app's title and icon, NOT the binary - so before an **Android**
 deploy (`.apk` or `.zip`), check the actual file yourself. These checks use the Android SDK
 build-tools (`aapt`/`aapt2`, `apksigner`); if they aren't installed, say so instead of
-silently skipping. (HTML5 `.zip` web bundles are exempt - they have no package name or signing.)
+silently skipping.
 
 1. **Package name matches the bound app.** The APK's package must equal the app's package
    name (`app_pkg_name` from `nowrun app list`, i.e. what you bound with `nowrun use`). A
@@ -244,16 +251,20 @@ Common cases:
 - **`MODE_REQUIRED` / `ADMIN_MODE_REQUIRED` / `NOT_ADMIN`:** see "Personal vs admin mode".
 - **`NETWORK_ERROR`:** nowrun was unreachable; retry. The session is still valid.
 - **Not signed in (401, `SESSION_EXPIRED`):** the session is gone. Ask the human to run `nowrun login`.
-- **In progress (429):** a deploy is already running. Poll `nowrun status`; don't retry the deploy.
+- **`DEPLOY_IN_PROGRESS` (429):** a deploy is already running for this app. Poll `nowrun status`,
+  or `nowrun cancel` to stop it, then deploy again - don't just retry.
+- **`NO_DEPLOY_IN_PROGRESS` (404, on cancel):** nothing was building, so there was nothing to cancel.
 
 ## Rules & gotchas
 
 - **Deploy is async.** After `deploy`, poll `status`; `job_status: progress` means the
-  cloud build is running; `success` yields the live URL.
-- **`submitted` means "in review," not failed.** A 429 with "in progress" means a
-  deployment is already running, poll, don't retry.
-- **There is one deployment per app.** `nowrun deploy` publishes it to a single live
-  public link - there are no separate tracks or environments to choose or promote to.
+  cloud build is running; `success` means it's live and runnable in ChatGPT.
+- **`submitted` means "in review," not failed.** A 429 (`DEPLOY_IN_PROGRESS`) means a
+  deployment is already running: poll `nowrun status`, or `nowrun cancel` and redeploy - don't retry.
+- **There is one deployment per app, one build at a time.** `nowrun deploy` publishes to a
+  single live public link - no separate tracks or environments to choose or promote to - and a
+  new build can't start (or upload) while one is in progress. `nowrun status` shows what's live
+  and what's building; `nowrun cancel` clears an in-progress build so you can deploy again.
 - **`app delete` is permanent.** Only run it on an explicit user request, confirm the exact
   `app_id`, and pass `--yes` when running non-interactively (it otherwise asks to confirm).
 - **Admin tools are for nowrun admins only**, in admin mode, and only when the human asks:
@@ -267,8 +278,13 @@ Common cases:
   exact ids (for `delete`, that they understand it can't be undone).
 - **Provisioning an app from a build link (nowrun admins, admin mode):**
   `nowrun admin apps fetch-apk -a <app_id> --url <link> [--expected-package <pkg>]` downloads
-  the APK server-side and reports its package, version, size and SHA-256 - it does NOT deploy.
-  These are untrusted third-party builds: review the reported package/version, then add
-  `--deploy` (which confirms first unless `--yes`) to deploy the staged build. `PACKAGE_MISMATCH`
-  means the build's package isn't the one you expected - fetch the right build.
+  the build **onto this machine**, reads its package/version/size/SHA-256 **locally**, and
+  reports them - it does NOT deploy. (The download and, on deploy, the upload happen from here,
+  not through nowrun's servers - a local machine is faster and metadata is read locally.) The
+  link may be a `.apk` or a wrapper `.zip` that contains the APK (e.g. a now.gg apps-content
+  package); the version is read from the base APK either way. These are untrusted third-party
+  builds: review the reported package/version, then add `--deploy` (which confirms first unless
+  `--yes`) to deploy it through the normal upload flow - the same path as `nowrun deploy -f`,
+  which also refuses a build whose package doesn't match the bound app. `PACKAGE_MISMATCH` means
+  the build's package isn't the one you passed to `--expected-package` - fetch the right build.
 - For any command or argument you're unsure about, **read `nowrun <cmd> -h`**, never invent flags.

{nowrun-2.0.0 → nowrun-2.0.2}/nowrun.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nowrun
-Version: 2.0.0
+Version: 2.0.2
 Summary: CLI to deploy and manage Android and HTML5 apps on nowrun.
 Home-page: https://nowrun.io
 Author: nowrun
@@ -14,12 +14,12 @@ Description-Content-Type: text/markdown
 
 # nowrun CLI
 
-Deploy Android and HTML5 apps to a live URL - driven by your AI coding agent.
+Publish Android apps so people can run them inside ChatGPT - driven by your AI coding agent.
 
-`nowrun` publishes Android and HTML5 apps to [nowrun](https://nowrun.io) and streams each at a
-URL anyone can open in a browser, no install. You don't run deploy commands by hand: you set
-the CLI up once, then tell your agent to ship. Android works with any engine that builds an APK
-(native, Unity, Godot, Unreal); HTML5 games deploy as a zipped bundle.
+`nowrun` publishes Android apps to [nowrun](https://nowrun.io) so people can run them inside
+ChatGPT (and other AI assistants that connect to nowrun) - streamed into the conversation, no
+install and no app store. You don't run deploy commands by hand: you set the CLI up once, then
+tell your agent to ship. Works with any engine that builds an APK (native, Unity, Godot, Unreal).
 
 ## Quickstart
 
@@ -38,10 +38,10 @@ copy or paste. (`nowrun update` refreshes it later; `nowrun logout` signs out.)
 
 **3. Tell your agent.** Open your AI coding tool in your project and give it this prompt:
 
-> Deploy my app to nowrun and give me the live public URL using the nowrun CLI. If you need the steps, read https://nowrun.io/docs/skill.md
+> Deploy my app to nowrun so people can run it in ChatGPT using the nowrun CLI. If you need the steps, read https://nowrun.io/docs/skill.md
 
-Your agent creates (or reuses) the app, uploads the build, deploys it, and hands back the live
-URL. That's the whole flow.
+Your agent creates (or reuses) the app, uploads the build, and deploys it - and once it's live,
+people can run it inside ChatGPT. That's the whole flow.
 
 ## What your agent runs for you
 
@@ -56,13 +56,14 @@ They're here for reference (and the occasional manual run):
 | `nowrun app list` / `nowrun app show` | list your apps / show one, with its visibility and readiness |
 | `nowrun inspect app.apk` | read a build's package + version, no Android SDK needed |
 | `nowrun validate` | check what's missing before deploying |
-| `nowrun deploy -f app.apk` | deploy a build and get its live link (version read from the APK; `--wait` blocks until live) |
+| `nowrun deploy -f app.apk` | deploy a build so it's runnable in ChatGPT (version read from the APK; `--wait` blocks until live) |
 | `nowrun status -s <submission_id>` | poll until it's live |
 | `nowrun help --json` | full command list + workflow (what the agent reads) |
 
 `deploy` reads the build's package/version and **refuses to deploy a build whose package
-doesn't match the app**, so you never publish to the wrong place. Add `--json` (in any
-position) to any command for machine-readable output.
+doesn't match the app**, so you never publish to the wrong place. It also **refuses a version
+code that isn't higher than the one currently live** (like the Play Store), so you can't ship a
+downgrade. Add `--json` (in any position) to any command for machine-readable output.
 
 New apps are private; a nowrun admin decides which deployed apps are listed in ChatGPT.
 You stay signed in: the CLI refreshes its session automatically (for 30 days after last use).

{nowrun-2.0.0 → nowrun-2.0.2}/setup.py

@@ -5,7 +5,7 @@ long_description = (this_directory / "README.md").read_text(encoding="utf-8")
 
 setup(
     name='nowrun',
-    version='v2.0.0',
+    version='v2.0.2',
     description='CLI to deploy and manage Android and HTML5 apps on nowrun.',
     long_description=long_description,
     long_description_content_type='text/markdown',