hivepods-cli 0.2.0__tar.gz → 0.2.1__tar.gz

{hivepods_cli-0.2.0 → hivepods_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hivepods-cli
-Version: 0.2.0
+Version: 0.2.1
 Summary: Command line interface for DockHive / HivePods
 Author: DockHive
 License: MIT
@@ -86,7 +86,7 @@ hivepod rm api                       # delete
 hivepod list                         # what you have
 hivepod status api                   # details + live CPU/RAM
 
-hivepod env api PORT=3000 --unset DEBUG   # change environment variables
+hivepod env api LOG_LEVEL=info --unset DEBUG   # change environment variables
 hivepod apply api                    # use them (recreates the environment; data/ and projects/ are kept)
 
 hivepod backup create api            # back up the data/ and projects/ folders
@@ -106,16 +106,21 @@ Windows 10+ console).
 
 ```bash
 cd my-app
-hivepod deploy                      # upload this folder; Drone builds and runs it
+hivepod deploy                      # upload this folder; Drone builds and deploys it
 hivepod deploy ./api --env DATABASE_URL=postgres://...   # set env vars (repeatable)
 hivepod deploy --app my-api         # redeploy a specific app
 hivepod deploy --no-wait            # return once the upload is accepted
 ```
 
-No Dockerfile or config needed: **Drone**, DockHive's AI deploy agent, reads your code,
-works out how to build and run it, and fixes the build if the first try fails. You see
-Drone's notes as it works, then the live URL. Deploying the same folder again updates the
-same app (`--new` makes a separate one).
+Zero config: **Drone**, DockHive's AI deploy agent, reads your code, builds your app and
+deploys it, and fixes problems along the way so it goes live. You see Drone's progress as
+it works ("Reading your code…", "Building your app…"), then the live URL. If your app
+needs settings such as `DATABASE_URL`, Drone tells you which ones; pass them with `--env`.
+`--verbose` shows the full build log. Deploying the same folder again updates the
+same app (`--new` makes a separate one). If the folder isn't a web service (a mobile or
+desktop app, a CLI or library, a background worker, notebooks, infrastructure config),
+Drone stops before building, says what it found and what to do instead (deploy the
+backend folder, or use a HivePod), and nothing is billed.
 
 What gets uploaded: the folder as a compressed archive (50 MB max) without `.git`,
 `node_modules`, virtualenvs, `__pycache__`, tool caches, large `dist`/`build` folders,
@@ -166,7 +171,7 @@ fail?"*, *"Add a Postgres database and wire it into the app"*.
 
 | Tool | What it does |
 |------|--------------|
-| `deploy` | Deploy a folder (`path`) or a GitHub repo (`repo_url`) with Drone; waits and returns the URL, or Drone's summary, missing env vars and the build log tail on failure |
+| `deploy` | Deploy a folder (`path`) or a GitHub repo (`repo_url`) with Drone; waits and returns the URL, or Drone's summary of the app, the env vars it needs and the build log tail on failure. Code that isn't a web service (mobile/desktop app, CLI, library, worker, notebooks, infra config) is an error with `kind`, `reason`, `suggestion` and `retryable: false` |
 | `deployment_status`, `build_logs` | Follow a deployment and read its build log |
 | `list_apps`, `app_logs` | Your apps, and a live app's runtime logs |
 | `set_env` | Set/unset an app's environment variables (values are write-only), optionally redeploy |

{hivepods_cli-0.2.0 → hivepods_cli-0.2.1}/README.md

@@ -62,7 +62,7 @@ hivepod rm api                       # delete
 hivepod list                         # what you have
 hivepod status api                   # details + live CPU/RAM
 
-hivepod env api PORT=3000 --unset DEBUG   # change environment variables
+hivepod env api LOG_LEVEL=info --unset DEBUG   # change environment variables
 hivepod apply api                    # use them (recreates the environment; data/ and projects/ are kept)
 
 hivepod backup create api            # back up the data/ and projects/ folders
@@ -82,16 +82,21 @@ Windows 10+ console).
 
 ```bash
 cd my-app
-hivepod deploy                      # upload this folder; Drone builds and runs it
+hivepod deploy                      # upload this folder; Drone builds and deploys it
 hivepod deploy ./api --env DATABASE_URL=postgres://...   # set env vars (repeatable)
 hivepod deploy --app my-api         # redeploy a specific app
 hivepod deploy --no-wait            # return once the upload is accepted
 ```
 
-No Dockerfile or config needed: **Drone**, DockHive's AI deploy agent, reads your code,
-works out how to build and run it, and fixes the build if the first try fails. You see
-Drone's notes as it works, then the live URL. Deploying the same folder again updates the
-same app (`--new` makes a separate one).
+Zero config: **Drone**, DockHive's AI deploy agent, reads your code, builds your app and
+deploys it, and fixes problems along the way so it goes live. You see Drone's progress as
+it works ("Reading your code…", "Building your app…"), then the live URL. If your app
+needs settings such as `DATABASE_URL`, Drone tells you which ones; pass them with `--env`.
+`--verbose` shows the full build log. Deploying the same folder again updates the
+same app (`--new` makes a separate one). If the folder isn't a web service (a mobile or
+desktop app, a CLI or library, a background worker, notebooks, infrastructure config),
+Drone stops before building, says what it found and what to do instead (deploy the
+backend folder, or use a HivePod), and nothing is billed.
 
 What gets uploaded: the folder as a compressed archive (50 MB max) without `.git`,
 `node_modules`, virtualenvs, `__pycache__`, tool caches, large `dist`/`build` folders,
@@ -142,7 +147,7 @@ fail?"*, *"Add a Postgres database and wire it into the app"*.
 
 | Tool | What it does |
 |------|--------------|
-| `deploy` | Deploy a folder (`path`) or a GitHub repo (`repo_url`) with Drone; waits and returns the URL, or Drone's summary, missing env vars and the build log tail on failure |
+| `deploy` | Deploy a folder (`path`) or a GitHub repo (`repo_url`) with Drone; waits and returns the URL, or Drone's summary of the app, the env vars it needs and the build log tail on failure. Code that isn't a web service (mobile/desktop app, CLI, library, worker, notebooks, infra config) is an error with `kind`, `reason`, `suggestion` and `retryable: false` |
 | `deployment_status`, `build_logs` | Follow a deployment and read its build log |
 | `list_apps`, `app_logs` | Your apps, and a live app's runtime logs |
 | `set_env` | Set/unset an app's environment variables (values are write-only), optionally redeploy |

{hivepods_cli-0.2.0 → hivepods_cli-0.2.1}/hivepods_cli/__init__.py

@@ -6,4 +6,4 @@ import warnings
 # noise for CLI users. Filtered before anything imports urllib3.
 warnings.filterwarnings("ignore", message=r"urllib3 v2 only supports OpenSSL")
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{hivepods_cli-0.2.0 → hivepods_cli-0.2.1}/hivepods_cli/client.py

@@ -207,12 +207,15 @@ class APIClient:
                                      timeout=timeout, **kwargs)
             raise APIError("Please sign in first: run `hivepod login`.", 401)
         if resp.status_code == 403:
-            raise APIError("Permission denied for this resource.", 403, _json_or_none(resp))
+            raise APIError(_forbidden_message(resp), 403, _json_or_none(resp))
         if resp.status_code == 404:
             raise APIError("Not found.", 404, _json_or_none(resp))
         if resp.status_code >= 500:
             raise APIError(_server_message(resp), resp.status_code, _json_or_none(resp))
         if resp.status_code >= 400:
+            data = _json_or_none(resp) or {}
+            if data.get("code") in BOT_CHECK_CODES:
+                raise APIError(BROWSER_SIGN_IN, resp.status_code, data)
             raise APIError(_format_error(resp), resp.status_code, _json_or_none(resp))
         if resp.status_code == 204 or not resp.content:
             return None
@@ -628,6 +631,29 @@ def _clean(text: str) -> Optional[str]:
     return text[:300]
 
 
+BROWSER_SIGN_IN = ("Email and password sign-in isn't available from the terminal. "
+                   "Run `hivepod login` to sign in through your browser.")
+BOT_CHECK_CODES = {"turnstile_failed", "turnstile_unavailable", "form_expired"}
+
+
+def _forbidden_message(resp) -> str:
+    """Explain a 403: unverified email, suspended account, bot check, or plain permission."""
+    if (getattr(resp, "headers", None) or {}).get("cf-mitigated"):
+        return BROWSER_SIGN_IN if "/auth/" in (getattr(resp, "url", "") or "") else (
+            "This request was blocked by DockHive's protection. Try again from your browser.")
+    data = _json_or_none(resp) or {}
+    code = data.get("code")
+    if code == "email_unverified":
+        return ("Verify your email to continue. Check your inbox for the code, "
+                "or open https://console.dockhive.io to resend it.")
+    if code == "account_suspended":
+        return _clean(data.get("error") or data.get("message") or "") or (
+            "Your account is suspended. Contact DockHive support.")
+    if code in BOT_CHECK_CODES:
+        return BROWSER_SIGN_IN
+    return "Permission denied for this resource."
+
+
 def _server_message(resp) -> str:
     if resp.status_code in (502, 503, 504):
         return "DockHive is temporarily unavailable. Please try again in a moment."

{hivepods_cli-0.2.0 → hivepods_cli-0.2.1}/hivepods_cli/deploy.py

@@ -32,6 +32,90 @@ def _noop(*_a, **_k):
     return None
 
 
+# Deployment stages in the user's words (the API's status values are an enum).
+STATUS_LABELS = {
+    "queued": "Queued", "uploading": "Uploading", "extracting": "Unpacking",
+    "cloning": "Fetching code", "building": "Building", "starting": "Starting",
+    "health_check": "Starting your app", "switching": "Going live", "deployed": "Live",
+    "failed": "Failed",
+}
+
+
+def status_label(status: Optional[str]) -> str:
+    return STATUS_LABELS.get(status or "", status or "Working")
+
+
+# --------------------------------------------------------------------------- Drone log
+# Older deployers wrote how Drone works inside into the build log (the build file it
+# wrote, the port it picked, AI usage). Those lines are hidden or reworded; current
+# deployers no longer write them. The raw build output itself is kept for debugging.
+_DRONE_FIX_RE = re.compile(r"^\[drone\] (?:build failed|health check failed|asking again)\b.*?"
+                           r"\(attempt (\d+)/(\d+)\)", re.I)
+_DRONE_HIDDEN_RE = re.compile(r"^\[drone\] (?:detected[: ]|plan:|ai usage|the ai|your saved build setup "
+                              r"failed|reusing your saved)", re.I)
+_DRONE_INTERNALS_RE = re.compile(r"dockerfile|health[ -]?check|health path|\bports?\b|base image|"
+                                 r"\bpreset\b|ai provider|\btokens?\b", re.I)
+
+
+def drone_log_filter() -> Callable[[str], Optional[str]]:
+    """A per-stream filter: the line to show (reworded when an older deployer wrote it),
+    or None for a line that describes Drone's internals."""
+    state = {"in_build_file": False}
+
+    def keep(line: str) -> Optional[str]:
+        if not isinstance(line, str):
+            return None
+        if state["in_build_file"]:
+            if line.startswith("  | "):
+                return None
+            state["in_build_file"] = False
+        if not line.startswith(DRONE_PREFIX):
+            return line
+        if re.match(r"^\[drone\] wrote dockerfile", line, re.I):
+            state["in_build_file"] = True
+            return "[drone] Building your app…"
+        m = _DRONE_FIX_RE.match(line)
+        if m:
+            return f"[drone] Found a problem, fixing it (attempt {m.group(1)}/{m.group(2)})…"
+        if re.match(r"^\[drone\] build and health check passed", line, re.I):
+            return "[drone] Your app is running, going live…"
+        m = re.match(r"^\[drone\] giving up after (\d+)", line, re.I)
+        if m:
+            return f"[drone] Couldn't get your app live after {m.group(1)} attempts"
+        m = re.match(r"^\[drone\] missing environment variables: ([A-Za-z0-9_, ]+)", line, re.I)
+        if m:
+            return f"[drone] Your app needs these environment variables: {m.group(1).strip()}"
+        if _DRONE_HIDDEN_RE.match(line) or _DRONE_INTERNALS_RE.search(line):
+            return None
+        return line
+
+    return keep
+
+
+def filter_drone_log(lines: List[str]) -> List[str]:
+    keep = drone_log_filter()
+    return [kept for kept in (keep(line) for line in lines) if kept is not None]
+
+
+def drone_message(message: Optional[str]) -> str:
+    """A Drone deployment's error in user terms (older deployers put internals in it)."""
+    m = (message or "").strip()
+    if not m:
+        return ""
+    found = re.match(r"^missing environment variables: ([A-Za-z0-9_, ]+)", m, re.I)
+    if found:
+        return (f"Your app needs these environment variables: {found.group(1).strip()}. "
+                "Add them and deploy again.")
+    found = re.match(r"^Drone could not deploy this app after (\d+)", m, re.I)
+    if found:
+        return (f"Drone couldn't get this app live after {found.group(1)} attempts. Check the build "
+                "log, fix the problem in your code and deploy again.")
+    if _DRONE_INTERNALS_RE.search(m):
+        return ("Drone couldn't get this app live. Check the build log, fix the problem in your "
+                "code and deploy again.")
+    return m
+
+
 # --------------------------------------------------------------------------- inputs
 def parse_env_pairs(items) -> Dict[str, str]:
     """['A=1', 'B=x=y'] -> {'A': '1', 'B': 'x=y'}; raises ValueError on a bad item."""
@@ -235,11 +319,12 @@ def wait_for_deployment(client: APIClient, deployment: dict, *, timeout: float =
     errors = 0
     tick = 0
     last_status = None
+    keep = drone_log_filter()
 
     def pull_logs():
         nonlocal after
         chunk = client.deployment_logs(dep_id, after, region)
-        new = [str(x) for x in chunk["lines"]]
+        new = [kept for kept in (keep(str(x)) for x in chunk["lines"]) if kept is not None]
         after = chunk["next"]
         if new:
             lines.extend(new)
@@ -290,6 +375,24 @@ def deployment_url(dep: dict) -> Optional[str]:
     return None
 
 
+NOT_DEPLOYABLE = "not_deployable"
+KIND_LABELS = {
+    "web_app": "a web app", "api": "an API", "static_site": "a static site",
+    "fullstack": "a full-stack app", "worker": "a background worker", "cli": "a command-line tool",
+    "library": "a library", "mobile_app": "a mobile app", "desktop_app": "a desktop app",
+    "notebook": "a set of notebooks", "infra_config": "an infrastructure/config repository",
+    "empty": "an empty repository", "other": "something other than a web service",
+}
+
+
+def kind_label(kind: Optional[str]) -> str:
+    return KIND_LABELS.get(kind or "", KIND_LABELS["other"])
+
+
+def _text(v: Any) -> str:
+    return " ".join(v.split()) if isinstance(v, str) else ""
+
+
 def drone_info(dep: dict) -> Optional[Dict[str, Any]]:
     d = dep.get("drone")
     if not isinstance(d, dict):
@@ -303,9 +406,34 @@ def drone_info(dep: dict) -> Optional[Dict[str, Any]]:
     }
     if isinstance(d.get("max_attempts"), int):
         out["max_attempts"] = d["max_attempts"]
+    if out["status"] == NOT_DEPLOYABLE:
+        out["kind"] = d.get("kind") if isinstance(d.get("kind"), str) else "other"
+        out["reason"] = _text(d.get("reason"))
+        out["suggestion"] = _text(d.get("suggestion"))
+        root = d.get("suggested_root_directory")
+        out["suggested_root_directory"] = root if isinstance(root, str) and root else None
     return out
 
 
+def not_deployable(info: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+    """{kind, reason, suggestion, suggested_root_directory} when Drone refused the code
+    (it is not a web service), else None."""
+    if not info or info.get("status") != NOT_DEPLOYABLE:
+        return None
+    return {k: info.get(k) for k in ("kind", "reason", "suggestion", "suggested_root_directory")}
+
+
+def not_deployable_text(nd: Dict[str, Any]) -> str:
+    """One sentence: "Drone can't deploy this: it looks like a mobile app (reason). Suggestion"."""
+    text = f"Drone can't deploy this: it looks like {kind_label(nd.get('kind'))}, not a web service"
+    if nd.get("reason"):
+        text += f" ({nd['reason'].rstrip('.')})"
+    text += "."
+    if nd.get("suggestion"):
+        text += " " + nd["suggestion"]
+    return text
+
+
 def summarize(dep: dict, lines: List[str], outcome: str = "finished",
               source: str = "upload") -> Dict[str, Any]:
     """The result an agent (or the CLI) needs: status, URL, Drone notes, failure log."""
@@ -321,9 +449,9 @@ def summarize(dep: dict, lines: List[str], outcome: str = "finished",
         out["version"] = dep.get("version")
     if dep.get("region"):
         out["region"] = dep["region"]
-    if dep.get("message"):
-        out["message"] = dep["message"]
     drone = drone_info(dep)
+    if dep.get("message"):
+        out["message"] = drone_message(dep["message"]) if drone else dep["message"]
     if drone:
         out["drone"] = drone
     if outcome == "timeout":
@@ -331,16 +459,29 @@ def summarize(dep: dict, lines: List[str], outcome: str = "finished",
                        "Check it with deployment_status.")
     elif outcome == "cancelled":
         out["note"] = "Stopped waiting (cancelled); the deployment continues on the server."
+    nd = not_deployable(drone)
+    if nd:
+        # Drone read the code and stopped before building: nothing to fix by retrying
+        out["not_deployable"] = nd
+        out["retryable"] = False
+        hints = [nd["suggestion"]] if nd.get("suggestion") else []
+        if nd.get("suggested_root_directory"):
+            hints.append(f"Deploy the `{nd['suggested_root_directory']}` folder instead (set the app's "
+                         f"Root directory to it, or deploy that folder's path).")
+        hints.append("Don't retry the same deploy: Drone will refuse it again until the code or the "
+                     "Root directory changes.")
+        out["next_steps"] = hints
+        return out
     if status == "failed" or (outcome == "finished" and status not in ("deployed",)):
         out["log_tail"] = lines[-FAIL_LOG_LINES:]
         hints = []
         if drone and drone["missing_env"]:
             names = ", ".join(drone["missing_env"])
             if source == "upload":
-                hints.append(f"The app needs environment variables: {names}. Deploy again "
+                hints.append(f"Your app needs these environment variables: {names}. Deploy again "
                              f"with env set (or set_env, then deploy the folder again).")
             else:
-                hints.append(f"The app needs environment variables: {names}. Call set_env "
+                hints.append(f"Your app needs these environment variables: {names}. Call set_env "
                              f"with redeploy=true.")
         if hints:
             out["next_steps"] = hints

{hivepods_cli-0.2.0 → hivepods_cli-0.2.1}/hivepods_cli/main.py

@@ -70,7 +70,8 @@ def login(email, password, use_browser, url):
         try:
             result = start_login(cfg["web_url"])
         except RuntimeError as exc:
-            die(f"{exc}\nTry `hivepod login --no-browser` to sign in with email and password.")
+            die(f"{exc}\nIf no browser can open here, create an API key in the console "
+                "(Settings → API keys) and set HIVEPODS_TOKEN.")
         update_config(token=result.token, refresh_token=result.refresh)
         console.print("[green]✓ Signed in[/green]")
         return
@@ -794,19 +795,14 @@ def exec_cmd(pod, command):
 # --------------------------------------------------------------------------
 # apps: deploy
 # --------------------------------------------------------------------------
-_DEPLOY_LABELS = {
-    "queued": "Queued", "uploading": "Uploading", "extracting": "Unpacking",
-    "cloning": "Fetching code", "building": "Building", "starting": "Starting",
-    "health_check": "Checking health", "switching": "Going live",
-}
-
-
-@cli.command(help="Deploy the app in PATH (default: this folder) with Drone, zero config.")
+@cli.command(help="Deploy the app in PATH (default: this folder) with Drone, DockHive's AI deploy "
+                  "agent: it reads your code, builds your app and deploys it. Zero config.")
 @click.argument("path", required=False, default=".", type=click.Path(file_okay=False))
 @click.option("--name", default=None, help="Name for a new app (default: the folder name).")
 @click.option("--app", "project_id", default=None, help="Id of an existing app to redeploy.")
 @click.option("--framework", default=None,
-              help="Build mode: drone (default for new apps), a framework id, or dockerfile.")
+              help="Build mode: drone (default for new apps), a framework id, or dockerfile "
+                   "(use your own Dockerfile).")
 @click.option("--env", "env", multiple=True, help="Environment variable KEY=VALUE (repeatable).")
 @click.option("--root", "root_directory", default=None, help="Sub-folder holding the app (monorepos).")
 @click.option("--new", "new_app", is_flag=True, help="Create a new app even if this folder was deployed before.")
@@ -866,10 +862,12 @@ def deploy(path, name, project_id, framework, env, root_directory, new_app, no_w
                     console.out(line, style="dim", highlight=False)
 
         def on_status(d):
-            label = _DEPLOY_LABELS.get(d.get("status"), d.get("status") or "Working")
+            label = dp.status_label(d.get("status"))
             drone = d.get("drone") if isinstance(d.get("drone"), dict) else None
-            if drone and drone.get("attempts", 0) > 1:
-                label += f" (attempt {drone['attempts']})"
+            if drone and drone.get("status") == "fixing":
+                label = f"Fixing a problem (attempt {drone.get('attempts', 0) + 1})"
+            elif drone and drone.get("status") == "analyzing":
+                label = "Reading your code"
             spinner.update(f"{label} {pid}…")
 
         try:
@@ -886,13 +884,25 @@ def deploy(path, name, project_id, framework, env, root_directory, new_app, no_w
     if result["live"]:
         console.print(f"\n[bold green]✓ Live[/bold green]  {result.get('url') or ''}")
         return
+    nd = result.get("not_deployable")
+    if nd:
+        console.print(f"\n[bold yellow]✗ Not deployable as an app[/bold yellow]  "
+                      f"(this looks like {dp.kind_label(nd.get('kind'))})", highlight=False)
+        if nd.get("reason"):
+            console.print(f"[magenta]drone[/magenta] {nd['reason']}", highlight=False)
+        for step in result.get("next_steps") or []:
+            console.print(f"  → {step}", highlight=False)
+        console.print("[dim]Nothing was built, so no build minutes were used.[/dim]")
+        sys.exit(1)
     console.print(f"\n[bold red]✗ Deployment {result['status']}[/bold red]")
     drone = result.get("drone") or {}
     if drone.get("summary"):
         console.print(f"[magenta]drone[/magenta] {drone['summary']}", highlight=False)
     if drone.get("missing_env"):
-        console.print("[yellow]Missing environment variables:[/yellow] " + ", ".join(drone["missing_env"])
-                      + "\nDeploy again with --env NAME=value for each.")
+        console.print("[yellow]Your app needs these environment variables:[/yellow] "
+                      + ", ".join(drone["missing_env"]) + "\nDeploy again with --env NAME=value for each.")
+    elif drone and result.get("message"):
+        console.print(result["message"], highlight=False)
     if result.get("log_tail") and not verbose:
         console.print("[dim]Last build log lines:[/dim]")
         for line in result["log_tail"]:

{hivepods_cli-0.2.0 → hivepods_cli-0.2.1}/hivepods_cli/mcp_server.py

@@ -46,11 +46,15 @@ INSTRUCTIONS = """\
 DockHive hosts apps, databases and cloud dev environments (HivePods).
 
 Deploying: call `deploy` with `path` set to the project folder (absolute path). Drone, \
-DockHive's AI deploy agent, works out how to build and run the app; no Dockerfile or \
-config is needed. The tool waits until the app is live and returns its URL; on failure \
-it returns Drone's summary, any missing environment variables and the end of the build \
-log. To update an app, deploy the same folder again (it is linked to the app it created) \
-or pass `project_id`. Put configuration in `env`; local .env files and keys are never \
+DockHive's AI deploy agent, reads the code, builds the app and deploys it, fixing \
+problems along the way; no configuration is needed. The tool waits until the app is live \
+and returns its URL; on failure it returns Drone's summary of the app, any environment \
+variables the app needs and the end of the build log. If Drone says the code is not deployable as an app (a mobile or desktop app, CLI, \
+library, background worker, notebooks, infrastructure config or an empty repo), the error \
+has `kind`, `reason`, `suggestion` and `retryable: false`: don't retry the same deploy, \
+tell the user and follow the suggestion (e.g. deploy the backend folder, or use a \
+HivePod). To update an app, deploy the same folder again (it is linked to the app it \
+created) or pass `project_id`. Put configuration in `env`; local .env files and keys are never \
 uploaded.
 
 Need a database? `create_database`, then put the returned connection string in the \
@@ -501,7 +505,7 @@ def _follow(ctx: Context, dep: dict, wait: bool, timeout_seconds: int, source: s
                 ctx.progress(line[len(deploy_mod.DRONE_PREFIX):])
 
     def on_status(d):
-        ctx.progress(f"status: {d.get('status')}")
+        ctx.progress(deploy_mod.status_label(d.get("status")))
 
     final, lines, outcome = deploy_mod.wait_for_deployment(
         ctx.client, dep, timeout=timeout_seconds, region=dep.get("region"),
@@ -516,31 +520,45 @@ def _follow(ctx: Context, dep: dict, wait: bool, timeout_seconds: int, source: s
         out["summary"] = f"Still {out['status']} after {timeout_seconds}s; it keeps going on the server."
     elif outcome == "cancelled":
         out["summary"] = "Stopped waiting; the deployment continues on the server."
+    elif out.get("not_deployable"):
+        nd = out["not_deployable"]
+        out["summary"] = deploy_mod.not_deployable_text(nd)
+        # structured, so an agent can tell this apart from a build failure and not retry
+        raise ToolError(out["summary"] + " Not retryable: change the code or the Root directory first.",
+                        {**out, "kind": nd.get("kind"), "reason": nd.get("reason"),
+                         "suggestion": nd.get("suggestion")})
     else:
         drone = out.get("drone") or {}
-        out["summary"] = f"Deployment {out['status']}." + (f" Drone: {drone['summary']}" if drone.get("summary") else "")
+        parts = [f"Deployment {out['status']}."]
+        if drone and out.get("message"):
+            parts.append(out["message"].rstrip(".") + ".")
+        if drone.get("summary"):
+            parts.append(f"Drone: {drone['summary']}")
+        out["summary"] = " ".join(parts)
     if out["status"] == "failed":
         raise ToolError(out["summary"], out)
     return out
 
 
 @tool("deploy", "Deploy an app",
-      "Deploy an app to DockHive with Drone, the AI deploy agent: zero config, no Dockerfile "
-      "needed. Give `path` (the project folder, absolute path; defaults to the server's "
+      "Deploy an app to DockHive with Drone, the AI deploy agent: it reads the code, builds "
+      "the app and deploys it, zero config. Give `path` (the project folder, absolute path; defaults to the server's "
       "working directory) to upload local code, or `repo_url` (+ optional `branch`) to deploy "
       "from GitHub. The folder is packaged as tar.gz (max 50 MB compressed) without .git, "
       "node_modules, virtualenvs, caches, .env files, keys, or anything in .gitignore / "
       ".dockhiveignore. Redeploying the same folder updates the app it created; pass "
       "`project_id` to target a specific app, or `new_app: true` to force a new one. With "
-      "wait=true (default) it returns when the app is live (URL) or failed (Drone summary, "
-      "missing env vars, last 60 build-log lines).",
+      "wait=true (default) it returns when the app is live (URL) or failed (Drone's summary "
+      "of the app, env vars it needs, last 60 build-log lines). Code that is not a web service (mobile/"
+      "desktop app, CLI, library, worker, notebooks, infra config) fails fast with "
+      "kind/reason/suggestion and retryable=false: do not retry it unchanged.",
       {
           "path": {"type": "string", "description": "Absolute path of the project folder to upload. Defaults to the MCP server's working directory. Not with repo_url."},
           "repo_url": {"type": "string", "description": "https:// Git repository URL to deploy instead of a local folder (uses your connected GitHub account for private repos)."},
           "branch": {"type": "string", "description": "Branch to deploy (repo_url only; default: the repo's main branch)."},
           "name": {"type": "string", "maxLength": 100, "description": "Display name for a new app (default: the folder or repo name)."},
           "project_id": PROJECT_ID,
-          "framework": {"type": "string", "description": "Build mode. \"drone\" (default for new apps) lets the AI agent build it; a framework id (e.g. \"nextjs\", \"django\") or \"dockerfile\" uses that preset. Existing apps keep their setting unless given."},
+          "framework": {"type": "string", "description": "Build mode. \"drone\" (default for new apps) lets Drone, the AI deploy agent, build and deploy it; a framework id (e.g. \"nextjs\", \"django\") uses that framework's setup, and \"dockerfile\" uses the project's own Dockerfile. Existing apps keep their setting unless given."},
           "env": ENV_OBJ,
           "root_directory": {"type": "string", "description": "Sub-folder that holds the app, for monorepos (e.g. \"apps/web\")."},
           "new_app": {"type": "boolean", "default": False, "description": "Create a new app even if this folder was deployed before."},
@@ -583,7 +601,7 @@ def t_deploy(ctx: Context, path: Optional[str] = None, repo_url: Optional[str] =
 
 @tool("deployment_status", "Deployment status",
       "Current status of one deployment: queued/building/.../deployed/failed, the URL, "
-      "Drone's progress (status, attempts, summary, missing env vars) and, if it failed, "
+      "Drone's progress (status, attempts, summary of the app, env vars it needs) and, if it failed, "
       "the last 60 build-log lines.",
       {"deployment_id": DEPLOYMENT_ID}, required=("deployment_id",), read_only=True)
 def t_deployment_status(ctx: Context, deployment_id: str):
@@ -599,13 +617,16 @@ def t_deployment_status(ctx: Context, deployment_id: str):
     out = deploy_mod.summarize(dep, lines, outcome)
     if outcome == "running":
         out.pop("log_tail", None)
-        out["summary"] = f"In progress: {status}."
+        out["summary"] = f"In progress: {deploy_mod.status_label(status)}."
+    elif out.get("not_deployable"):
+        out["summary"] = deploy_mod.not_deployable_text(out["not_deployable"])
     else:
         out["summary"] = f"Live at {out['url']}" if out["live"] else f"Deployment {status}."
     return out
 
 
 def _all_logs(client: APIClient, deployment_id: str, region: Optional[str]) -> List[str]:
+    """The whole build log, without lines that describe Drone's internals."""
     lines: List[str] = []
     after = 0
     for _ in range(20):
@@ -616,12 +637,12 @@ def _all_logs(client: APIClient, deployment_id: str, region: Optional[str]) -> L
         if chunk["next"] <= after:
             break
         after = chunk["next"]
-    return lines
+    return deploy_mod.filter_drone_log(lines)
 
 
 @tool("build_logs", "Build logs",
-      "Build/deploy log of a deployment (cloning, building, Drone's `[drone]` notes, health "
-      "check). Returns the last `tail` lines.",
+      "Build/deploy log of a deployment (fetching code, building, Drone's `[drone]` notes, "
+      "going live). Returns the last `tail` lines.",
       {"deployment_id": DEPLOYMENT_ID,
        "tail": {"type": "integer", "minimum": 1, "maximum": 2000, "default": 200,
                 "description": "Number of lines from the end (default 200)."}},

{hivepods_cli-0.2.0 → hivepods_cli-0.2.1}/hivepods_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hivepods-cli
-Version: 0.2.0
+Version: 0.2.1
 Summary: Command line interface for DockHive / HivePods
 Author: DockHive
 License: MIT
@@ -86,7 +86,7 @@ hivepod rm api                       # delete
 hivepod list                         # what you have
 hivepod status api                   # details + live CPU/RAM
 
-hivepod env api PORT=3000 --unset DEBUG   # change environment variables
+hivepod env api LOG_LEVEL=info --unset DEBUG   # change environment variables
 hivepod apply api                    # use them (recreates the environment; data/ and projects/ are kept)
 
 hivepod backup create api            # back up the data/ and projects/ folders
@@ -106,16 +106,21 @@ Windows 10+ console).
 
 ```bash
 cd my-app
-hivepod deploy                      # upload this folder; Drone builds and runs it
+hivepod deploy                      # upload this folder; Drone builds and deploys it
 hivepod deploy ./api --env DATABASE_URL=postgres://...   # set env vars (repeatable)
 hivepod deploy --app my-api         # redeploy a specific app
 hivepod deploy --no-wait            # return once the upload is accepted
 ```
 
-No Dockerfile or config needed: **Drone**, DockHive's AI deploy agent, reads your code,
-works out how to build and run it, and fixes the build if the first try fails. You see
-Drone's notes as it works, then the live URL. Deploying the same folder again updates the
-same app (`--new` makes a separate one).
+Zero config: **Drone**, DockHive's AI deploy agent, reads your code, builds your app and
+deploys it, and fixes problems along the way so it goes live. You see Drone's progress as
+it works ("Reading your code…", "Building your app…"), then the live URL. If your app
+needs settings such as `DATABASE_URL`, Drone tells you which ones; pass them with `--env`.
+`--verbose` shows the full build log. Deploying the same folder again updates the
+same app (`--new` makes a separate one). If the folder isn't a web service (a mobile or
+desktop app, a CLI or library, a background worker, notebooks, infrastructure config),
+Drone stops before building, says what it found and what to do instead (deploy the
+backend folder, or use a HivePod), and nothing is billed.
 
 What gets uploaded: the folder as a compressed archive (50 MB max) without `.git`,
 `node_modules`, virtualenvs, `__pycache__`, tool caches, large `dist`/`build` folders,
@@ -166,7 +171,7 @@ fail?"*, *"Add a Postgres database and wire it into the app"*.
 
 | Tool | What it does |
 |------|--------------|
-| `deploy` | Deploy a folder (`path`) or a GitHub repo (`repo_url`) with Drone; waits and returns the URL, or Drone's summary, missing env vars and the build log tail on failure |
+| `deploy` | Deploy a folder (`path`) or a GitHub repo (`repo_url`) with Drone; waits and returns the URL, or Drone's summary of the app, the env vars it needs and the build log tail on failure. Code that isn't a web service (mobile/desktop app, CLI, library, worker, notebooks, infra config) is an error with `kind`, `reason`, `suggestion` and `retryable: false` |
 | `deployment_status`, `build_logs` | Follow a deployment and read its build log |
 | `list_apps`, `app_logs` | Your apps, and a live app's runtime logs |
 | `set_env` | Set/unset an app's environment variables (values are write-only), optionally redeploy |

{hivepods_cli-0.2.0 → hivepods_cli-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hivepods-cli"
-version = "0.2.0"
+version = "0.2.1"
 description = "Command line interface for DockHive / HivePods"
 readme = "README.md"
 requires-python = ">=3.9"

{hivepods_cli-0.2.0 → hivepods_cli-0.2.1}/tests/test_client.py

@@ -226,3 +226,35 @@ def test_os_listing_has_no_internal_column(monkeypatch, tmp_path):
     for word in ("backend", "container", " vm "):
         assert word not in out
     assert "full machine" in out and "lightweight" in out
+
+
+@pytest.mark.parametrize("body, expected", [
+    ({"error": "x", "code": "email_unverified"}, "Verify your email to continue"),
+    ({"error": "Your account is suspended.", "code": "account_suspended"}, "Your account is suspended."),
+    ({"detail": "nope"}, "Permission denied for this resource."),
+])
+def test_forbidden_explains_why(calls, body, expected):
+    log, routes = calls
+    base = "https://gw.dockhive.sh"
+    routes[("GET", f"{base}/api/v1/hivepods/")] = lambda h, kw: FakeResp(403, body)
+    with pytest.raises(APIError) as exc:
+        APIClient(base, "tok").list_pods()
+    assert expected in str(exc.value)
+
+
+def test_password_login_blocked_by_bot_check_points_to_browser(calls):
+    log, routes = calls
+    base = "https://gw.dockhive.sh"
+    challenged = FakeResp(403, text="<html>challenge</html>")
+    challenged.headers = {"cf-mitigated": "challenge"}
+    challenged.url = f"{base}/api/v1/auth/login"
+    routes[("POST", f"{base}/api/v1/auth/login")] = lambda h, kw: challenged
+    with pytest.raises(APIError) as exc:
+        APIClient(base).login("a@b.co", "pw")
+    assert "hivepod login" in str(exc.value)
+
+    routes[("POST", f"{base}/api/v1/auth/login")] = \
+        lambda h, kw: FakeResp(400, {"error": "Complete the check.", "code": "turnstile_failed"})
+    with pytest.raises(APIError) as exc:
+        APIClient(base).login("a@b.co", "pw")
+    assert "browser" in str(exc.value)

{hivepods_cli-0.2.0 → hivepods_cli-0.2.1}/tests/test_deploy_cmd.py

@@ -59,6 +59,27 @@ def test_deploy_failure_exit_code(http, tmp_path):
     assert "DATABASE_URL" in res.output and "--env" in res.output
 
 
+def test_deploy_not_deployable_prints_the_suggestion(http, tmp_path):
+    from .test_mcp import NOT_DEPLOYABLE
+    root = make_project(tmp_path / "shop")
+    deploy_routes(http, final="failed", drone={**NOT_DEPLOYABLE, "kind": "cli",
+                                               "reason": "It is a click command-line tool.",
+                                               "suggestion": "Run it in a HivePod, or add a web interface "
+                                                             "or API to deploy it.",
+                                               "suggested_root_directory": None},
+                  logs=["[drone] Reading your code…",
+                        "[drone] This looks like a command-line tool: It is a click command-line tool.",
+                        "[drone] Not deployable as an app: Run it in a HivePod, or add a web interface "
+                        "or API to deploy it."])
+    res = run("deploy", str(root))
+    assert res.exit_code == 1
+    assert "Not deployable as an app" in res.output and "this looks like a command-line tool" in res.output
+    assert "It is a click command-line tool." in res.output
+    assert "Run it in a HivePod, or add a web interface or API to deploy it." in res.output
+    assert "no build minutes" in res.output
+    assert "Last build log lines" not in res.output and "Deployment failed" not in res.output
+
+
 def test_deploy_no_wait(http, tmp_path):
     root = make_project(tmp_path / "shop")
     deploy_routes(http)
@@ -85,3 +106,46 @@ def test_mcp_print_config():
     assert res.exit_code == 0
     assert "claude mcp add dockhive -- hivepod mcp" in res.output
     assert '"mcpServers"' in res.output and '"mcp"' in res.output
+
+
+# ------------------------------------------------------------- Drone copy (user level)
+
+def test_drone_internals_are_hidden_from_the_log():
+    from hivepods_cli import deploy as dp
+    log = [
+        "[drone] Reading your code…",
+        "[drone] Detected: Express (Node 22), port 3000",
+        "[drone] Wrote Dockerfile (multi-stage):",
+        "  | FROM node:22-bookworm-slim AS build",
+        "#5 [build 1/4] FROM docker.io/library/node:22-bookworm-slim",
+        "[drone] Build failed: npm ERR! Missing script. Fixing (attempt 2/3)…",
+        "[drone] AI usage: 1.2k tokens",
+        "[drone] Build and health check passed",
+        "[drone] Missing environment variables: DB_URL. Add them in the project settings.",
+        "[drone] Deployed",
+    ]
+    assert dp.filter_drone_log(log) == [
+        "[drone] Reading your code…",
+        "[drone] Building your app…",
+        "#5 [build 1/4] FROM docker.io/library/node:22-bookworm-slim",
+        "[drone] Found a problem, fixing it (attempt 2/3)…",
+        "[drone] Your app is running, going live…",
+        "[drone] Your app needs these environment variables: DB_URL",
+        "[drone] Deployed",
+    ]
+    assert dp.status_label("health_check") == "Starting your app"
+
+
+def test_drone_failure_message_is_user_level():
+    from hivepods_cli import deploy as dp
+    dep = {"deployment_id": "dep-1", "status": "failed",
+           "message": "Drone could not deploy this app after 3 attempt(s): health check failed: "
+                      "no HTTP response on port 3000",
+           "drone": {"status": "failed", "attempts": 3, "summary": "An Express API.", "missing_env": []}}
+    out = dp.summarize(dep, [])
+    assert out["message"].startswith("Drone couldn't get this app live after 3 attempts.")
+    assert "port" not in out["message"] and "health" not in out["message"]
+    for key in ("dockerfile", "port", "health_path"):
+        assert key not in out["drone"]
+    plain = dict(dep, drone=None, message="git clone failed: not found")
+    assert dp.summarize(plain, [])["message"] == "git clone failed: not found"

{hivepods_cli-0.2.0 → hivepods_cli-0.2.1}/tests/test_mcp.py

@@ -275,6 +275,58 @@ def test_deploy_failure_returns_drone_details_and_log_tail(server, http, tmp_pat
     assert "DATABASE_URL" in body["next_steps"][0]
 
 
+NOT_DEPLOYABLE = {"status": "not_deployable", "attempts": 0, "summary": "", "missing_env": [],
+                  "kind": "mobile_app",
+                  "reason": "it has a Flutter pubspec.yaml and no web/ folder, so it builds iOS and Android apps",
+                  "suggestion": "App hosting runs web apps and APIs. Deploy the app's backend, or its web "
+                                "build (Flutter web, Expo web), by setting the Root directory to that folder.",
+                  "suggested_root_directory": "backend"}
+
+
+def test_deploy_not_deployable_is_a_structured_non_retryable_error(server, http, tmp_path):
+    root = make_project(tmp_path / "shop")
+    logs = ["[drone] Reading your code…",
+            "[drone] This looks like a Flutter mobile app: it has a Flutter pubspec.yaml",
+            "[drone] Not deployable as an app: App hosting runs web apps and APIs."]
+    deploy_routes(http, final="failed", logs=logs, drone=NOT_DEPLOYABLE)
+    init(server, "2025-06-18")
+    res = call(server, "deploy", {"path": str(root)})
+    assert res["isError"] is True
+    msg = text(res).split("\n\n", 1)[0]
+    assert msg.startswith("Drone can't deploy this: it looks like a mobile app, not a web service "
+                          "(it has a Flutter pubspec.yaml")
+    assert "Not retryable" in msg
+    body = res["structuredContent"]
+    assert body["kind"] == "mobile_app" and body["reason"] == NOT_DEPLOYABLE["reason"]
+    assert body["suggestion"] == NOT_DEPLOYABLE["suggestion"] and body["retryable"] is False
+    assert body["not_deployable"]["suggested_root_directory"] == "backend"
+    assert "log_tail" not in body
+    assert body["next_steps"][0] == NOT_DEPLOYABLE["suggestion"]
+    assert any("`backend`" in s for s in body["next_steps"])
+    assert any("Don't retry" in s for s in body["next_steps"])
+
+    # deployment_status explains it the same way (not an error: it is a status query)
+    http.add("GET", DEP_PATH, {"deployment_id": DEP, "status": "failed", "drone": NOT_DEPLOYABLE,
+                               "message": "Drone can't deploy this"})
+    http.add("GET", LOGS_PATH, {"deployment_id": DEP, "status": "failed", "lines": logs, "next": 3},
+             {"deployment_id": DEP, "status": "failed", "lines": [], "next": 3})
+    res = call(server, "deployment_status", {"deployment_id": DEP})
+    assert not res.get("isError")
+    assert res["structuredContent"]["summary"].startswith("Drone can't deploy this: it looks like a mobile app")
+    assert res["structuredContent"]["not_deployable"]["kind"] == "mobile_app"
+
+
+def test_drone_info_ignores_verdict_fields_unless_not_deployable():
+    info = deploy_mod.drone_info({"drone": {"status": "failed", "attempts": 1, "summary": "", "missing_env": [],
+                                            "kind": None, "reason": None, "suggestion": None,
+                                            "suggested_root_directory": None}})
+    assert "kind" not in info and deploy_mod.not_deployable(info) is None
+    nd = deploy_mod.not_deployable(deploy_mod.drone_info({"drone": {"status": "not_deployable", "kind": 7}}))
+    assert nd == {"kind": "other", "reason": "", "suggestion": "", "suggested_root_directory": None}
+    assert deploy_mod.not_deployable_text(nd) == \
+        "Drone can't deploy this: it looks like something other than a web service, not a web service."
+
+
 def test_deploy_errors(server, http, tmp_path):
     root = make_project(tmp_path / "shop")
     http.add("POST", UPLOAD, (413, {"error": "archive too large"}))