socaity-cli 0.1.5__tar.gz → 0.1.7__tar.gz

{socaity_cli-0.1.5 → socaity_cli-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: socaity-cli
-Version: 0.1.5
+Version: 0.1.7
 Summary: Socaity platform CLI: login, catalog browsing, SDK installs and APIPod deployment commands.
 Author: SocAIty
 License: MIT

{socaity_cli-0.1.5 → socaity_cli-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "socaity-cli"
-version = "0.1.5"
+version = "0.1.7"
 description = "Socaity platform CLI: login, catalog browsing, SDK installs and APIPod deployment commands."
 requires-python = ">=3.8"
 authors = [

{socaity_cli-0.1.5 → socaity_cli-0.1.7}/socaity_cli/auth.py

@@ -7,6 +7,7 @@ import shutil
 import subprocess
 import time
 import webbrowser
+from importlib.metadata import PackageNotFoundError, version as pkg_version
 from typing import Any, Dict, Optional
 from urllib.parse import urljoin
 
@@ -20,7 +21,10 @@ from socaity_cli.credentials import (
     save_credentials,
 )
 
-USER_AGENT = "socaity-cli/0.1.0"
+try:
+    USER_AGENT = f"socaity-cli/{pkg_version('socaity-cli')}"
+except PackageNotFoundError:
+    USER_AGENT = "socaity-cli"
 
 
 def _backend_base_url() -> str:

socaity_cli-0.1.7/socaity_cli/deploy_messages.py

@@ -0,0 +1,171 @@
+"""User-facing copy for deploy progress and failures.
+
+Backend status/phase/error stay machine-readable. This module turns them
+into short sentences a non-technical user can follow in the CLI.
+"""
+from __future__ import annotations
+
+import os
+import re
+from typing import Any, Dict, Optional, Tuple
+
+from socaity_cli.credentials import DEFAULT_FRONTEND_URL
+
+_WORKER_COUNTS_RE = re.compile(
+    r"RunPod workers\s+ready=(?P<ready>\d+)\s+initializing=(?P<initializing>\d+)\s+"
+    r"unhealthy=(?P<unhealthy>\d+)\s+idle=(?P<idle>\d+)",
+    re.IGNORECASE,
+)
+
+_STEP_BY_STATUS = {
+    "draft": "Preparing your deployment...",
+    "awaiting_image": "Waiting to upload your image...",
+    "pushing": "Uploading your image...",
+    "validating": "Checking your image...",
+    "promoting": "Saving your image...",
+    "provisioning": "Starting your service...",
+    "live": "Your service is live.",
+    "failed_push": "Could not upload your image.",
+    "failed_validation": "Your image did not pass checks.",
+    "failed_provision": "Could not start your service.",
+    "cancelled": "This deployment was cancelled.",
+}
+
+_STEP_BY_PHASE = {
+    "queued_for_validation": "Checking your image...",
+    "vulnerability_scan": "Scanning your image for security issues...",
+    "promoting_image": "Saving your image...",
+    "provision_queued": "Starting your service...",
+    "waiting_for_service_health": "Waiting for your service to start...",
+    "waiting_for_openapi": "Your service is running. Finishing setup...",
+}
+
+
+def site_url() -> str:
+    return os.environ.get("SOCAITY_FRONTEND_URL", DEFAULT_FRONTEND_URL).rstrip("/")
+
+
+def service_page_url(service_id: Optional[str]) -> str:
+    base = site_url()
+    if service_id:
+        return f"{base}/account/my-services/{service_id}"
+    return f"{base}/account/hosting"
+
+
+def parse_worker_counts(text: Optional[str]) -> Optional[Dict[str, int]]:
+    if not text:
+        return None
+    match = _WORKER_COUNTS_RE.search(text)
+    if not match:
+        return None
+    return {key: int(value) for key, value in match.groupdict().items()}
+
+
+def is_progress_noise(text: Optional[str]) -> bool:
+    """True when a backend 'error' field is actually worker progress."""
+    if not text:
+        return False
+    if "traceback" in text.lower():
+        return False
+    return parse_worker_counts(text) is not None
+
+
+def _worker_detail(counts: Dict[str, int], phase: Optional[str]) -> str:
+    if counts.get("unhealthy", 0) > 0:
+        return "The machine reported a problem. Waiting to confirm..."
+    if counts.get("initializing", 0) > 0:
+        return "A machine is starting up. This can take a few minutes."
+    live = counts.get("ready", 0) + counts.get("idle", 0)
+    if live > 0:
+        if phase == "waiting_for_openapi":
+            return "Your service is running. Finishing setup..."
+        return "Your service is running. Almost done..."
+    return "Waiting for a machine. This can take a few minutes."
+
+
+def progress_lines(status: Dict[str, Any]) -> Tuple[str, Optional[str]]:
+    """Return ``(step, optional detail)`` for one poll snapshot."""
+    state = str(status.get("status") or "").strip().lower()
+    phase = status.get("phase")
+    phase_key = str(phase).strip() if phase else None
+    error = status.get("error")
+    analysis = status.get("analysis") if isinstance(status.get("analysis"), dict) else {}
+    hint = None
+    if isinstance(analysis, dict):
+        hint = analysis.get("runpod_progress")
+    hint = hint or (error if is_progress_noise(error) else None)
+
+    explicit = status.get("progress") or status.get("message")
+    if isinstance(explicit, str) and explicit.strip() and not is_progress_noise(explicit):
+        return explicit.strip(), None
+
+    step = _STEP_BY_PHASE.get(phase_key) or _STEP_BY_STATUS.get(state) or "Working on your deployment..."
+    detail = None
+    counts = parse_worker_counts(hint if isinstance(hint, str) else None)
+    if counts and state == "provisioning":
+        detail = _worker_detail(counts, phase_key)
+        if detail == step:
+            detail = None
+    return step, detail
+
+
+def humanize_failure(error: Optional[str], status: Optional[str] = None) -> str:
+    """One-sentence failure for the user. Technical text is not the headline."""
+    state = str(status or "").strip().lower()
+    text = (error or "").strip()
+    lower = text.lower()
+
+    if state == "cancelled":
+        return "This deployment was cancelled."
+    if is_progress_noise(text):
+        text = ""
+        lower = ""
+
+    if "user is stopped" in lower:
+        return (
+            "Your account is paused. Check billing, then try deploying again.\n"
+            f"  {site_url()}/account/billing"
+        )
+    if "no active" in lower and "vram" in lower:
+        return (
+            "No GPU with that much memory is available right now. "
+            "Lower gpu_vram_gb in your config, or try again later."
+        )
+    if "could not assign a worker" in lower:
+        return "We could not start a machine for your service. Please try again in a few minutes."
+    if "no live or starting workers" in lower or "no live workers" in lower:
+        return "The service stopped before it finished starting. Please try deploying again."
+    if "traceback" in lower or "container exited" in lower:
+        return "Your service crashed while starting. Fix the issue in your code, then deploy again."
+    if "could not promote" in lower or "harbor" in lower:
+        return "We could not save your image. Please try deploying again."
+    if "critical" in lower or "cve" in lower or "vulnerab" in lower:
+        return "Your image did not pass the security scan. Fix the reported issues, then deploy again."
+    if "openapi" in lower:
+        return (
+            "Your service started, but we could not read its API definition. "
+            "Make sure the service exposes /openapi.json, then deploy again."
+        )
+    if "quota" in lower or ("registry" in lower and "space" in lower):
+        return "Your image storage is full. Delete unused services, then try again."
+
+    if text:
+        return text
+    if state == "failed_push":
+        return "We could not upload your image. Check your connection and try again."
+    if state == "failed_validation":
+        return "Your image did not pass checks. Please try deploying again."
+    if state == "failed_provision":
+        return "We could not start your service. Please try deploying again."
+    return "Deployment did not finish. Please try again."
+
+
+def support_detail(error: Optional[str]) -> Optional[str]:
+    """Technical leftover to print under the human sentence, if useful."""
+    text = (error or "").strip()
+    if not text or is_progress_noise(text):
+        return None
+    human = humanize_failure(text)
+    if text == human or text in human:
+        return None
+    return text

{socaity_cli-0.1.5 → socaity_cli-0.1.7}/socaity_cli/deployment.py

@@ -10,7 +10,17 @@ from typing import Any, Dict, Optional
 
 from socaity_cli.backend_client import SocaityBackendClient
 from socaity_cli.credentials import require_credentials
-from socaity_cli.errors import PrivateSlotLimitError
+from socaity_cli.deploy_messages import (
+    humanize_failure,
+    progress_lines,
+    service_page_url,
+    support_detail,
+)
+from socaity_cli.errors import (
+    BackendApiError,
+    PrivateSlotLimitError,
+    RegistryQuotaExceededError,
+)
 from socaity_cli.prompts import input_yes_no
 from socaity_cli.registry_push import (
     CredentialsExpired,
@@ -29,6 +39,10 @@ _TERMINAL_STATUSES = frozenset({
     "cancelled",
 })
 _POLL_INTERVAL_S = 5.0
+# Harbor often returns 201 minutes after Docker's header timeout. Wait
+# before the next docker push so the blob can be skipped instead of
+# starting a second multi-GB PUT while the first commit is still running.
+_TRANSIENT_PUSH_BACKOFF_S = (120, 240, 360)
 _DEFAULT_TIMEOUT_S = 3600.0
 
 
@@ -44,15 +58,24 @@ def print_analysis_report(report: Dict[str, Any]) -> None:
             line += f" | catalog: {catalog.get('name')}{vram}"
         print(line)
         for warning in model.get("warnings", []):
-            print(f"    warning: {warning}")
+            print(f"    Note: {warning}")
     gpu = report.get("recommended_gpu")
-    if gpu:
-        print(f"  Recommended GPU tier: {gpu}")
+    vram = report.get("recommended_gpu_vram_gb")
+    if gpu and vram:
+        gpu_has_vram = str(int(vram)) in str(gpu)
+        print(f"  Recommended GPU: {gpu}" + ("" if gpu_has_vram else f" ({int(vram)} GB)"))
+    elif gpu:
+        print(f"  Recommended GPU: {gpu}")
+    elif vram:
+        print(f"  Recommended GPU memory: {int(vram)} GB")
+    disk = report.get("recommended_disk_gb")
+    if disk:
+        print(f"  Recommended disk: {disk} GB")
     for service in report.get("similar_services", []):
         name = service.get("display_name") or service.get("name")
-        print(f"  Similar public service: {name} (id={service.get('id')})")
+        print(f"  Similar public service: {name}")
     for warning in report.get("warnings", []):
-        print(f"  warning: {warning}")
+        print(f"  Note: {warning}")
 
 
 def analyze_deployment(config: Dict[str, Any]) -> Optional[Dict[str, Any]]:
@@ -113,6 +136,35 @@ def prompt_gated_hf_token(client: SocaityBackendClient, report: Dict[str, Any])
         print("Token not stored; gated repos will fail to download on deploy.")
 
 
+def apply_gpu_upgrade_if_needed(
+    config: Dict[str, Any],
+    report: Optional[Dict[str, Any]],
+    *,
+    assume_yes: bool = False,
+) -> bool:
+    """Ask to bump gpu_vram_gb when analyze offers a larger SKU. False aborts."""
+    upgrade = report.get("gpu_upgrade") if isinstance(report, dict) else None
+    if not upgrade:
+        return True
+    requested = upgrade.get("requested_vram_gb")
+    available = upgrade.get("available_vram_gb")
+    gpu = upgrade.get("gpu") or f"{available} GB"
+    question = (
+        f"No {requested} GB GPU is available. The next size is {available} GB "
+        f"({gpu}). Use the larger GPU?"
+    )
+    if assume_yes:
+        print(f"  {question} yes")
+        accepted = True
+    else:
+        accepted = input_yes_no(question)
+    if not accepted:
+        print("Aborted. Deploy will keep your current GPU size and will not pick a smaller one.")
+        return False
+    config["gpu_vram_gb"] = int(available)
+    return True
+
+
 def create_deployment_draft(config: Dict[str, Any], report: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
     """Create a deployment draft after optional confirmation."""
     require_credentials()
@@ -124,6 +176,9 @@ def create_deployment_draft(config: Dict[str, Any], report: Optional[Dict[str, A
             return None
         print_analysis_report(report)
 
+    if not apply_gpu_upgrade_if_needed(config, report):
+        return None
+
     resolutions = prompt_model_resolutions(report)
     prompt_gated_hf_token(client, report)
 
@@ -133,17 +188,28 @@ def create_deployment_draft(config: Dict[str, Any], report: Optional[Dict[str, A
 
     try:
         draft = client.create_deployment_draft(config, model_resolutions=resolutions)
-    except PrivateSlotLimitError as exc:
-        print(f"\n{exc}")
-        print("Tip: publish a private service from the service page, or upgrade your plan.")
+    except BackendApiError as exc:
+        if getattr(exc, "code", None) == "GPU_UPGRADE_AVAILABLE":
+            print(f"\n{exc}")
+            print("Confirm the larger GPU in analyze, or change gpu_vram_gb, then retry.")
+            return None
+        if getattr(exc, "code", None) == "AUTO_RECHARGE_REQUIRED":
+            print(f"\n{exc}")
+            print(
+                "Enable auto-recharge and save a card on Billing. "
+                "If a previous draft failed, delete that unused private service in My Services, then retry."
+            )
+            return None
+        if isinstance(exc, PrivateSlotLimitError):
+            print(f"\n{exc}")
+            print("Tip: publish a private service from the service page, or upgrade your plan.")
+            raise
         raise
     if draft is None:
         print("Draft creation failed.")
         return None
-    print(
-        f"Draft created: service_id={draft.get('service_id')} deployment_id={draft.get('deployment_id')}\n"
-        "Next: the image will be pushed to the Socaity registry and provisioned automatically."
-    )
+    print("Draft created. Next we will upload your image and start the service.")
+    print(f"  Resume later with: socaity deploy --resume {draft.get('deployment_id')}")
     return draft
 
 
@@ -156,9 +222,17 @@ def push_image_to_registry(
     """Push a local image to the deployment staging repo. Returns the manifest digest."""
     client = client or SocaityBackendClient()
     estimated_size = image_size_bytes(local_tag)
-    creds = client.get_push_credentials(deployment_id, estimated_size_bytes=estimated_size)
+    try:
+        creds = client.get_push_credentials(deployment_id, estimated_size_bytes=estimated_size)
+    except RegistryQuotaExceededError as exc:
+        print(f"\n{exc}")
+        print(
+            "This attempt was dropped so it does not occupy a private slot. "
+            "Delete unused services to free storage space, then deploy again."
+        )
+        return None
     if creds is None:
-        print("Could not obtain registry push credentials.")
+        print("Could not get permission to upload your image. Please try again.")
         return None
 
     refreshed = False
@@ -176,25 +250,39 @@ def push_image_to_registry(
             return digest
         except CredentialsExpired:
             if not refreshed:
-                print("Push credentials expired; requesting fresh credentials...")
-                creds = client.get_push_credentials(deployment_id, estimated_size_bytes=estimated_size)
+                print("Upload permission expired. Getting a new one...")
+                try:
+                    creds = client.get_push_credentials(deployment_id, estimated_size_bytes=estimated_size)
+                except RegistryQuotaExceededError as exc:
+                    print(f"\n{exc}")
+                    print(
+                        "This attempt was dropped so it does not occupy a private slot. "
+                        "Delete unused services to free storage space, then deploy again."
+                    )
+                    return None
                 if creds is None:
-                    print("Could not refresh registry push credentials.")
+                    print("Could not refresh upload permission. Please try again.")
                     return None
                 refreshed = True
                 continue
-            print("Registry rejected the push credentials again.")
+            print("Upload permission expired again. Please retry the deploy.")
             return None
         except DockerNotAvailable as exc:
             print(str(exc))
             return None
         except PushFailed as exc:
-            if is_transient_push_error(str(exc)) and transient_attempts < 2:
+            if (
+                is_transient_push_error(str(exc))
+                and transient_attempts < len(_TRANSIENT_PUSH_BACKOFF_S)
+            ):
+                wait = _TRANSIENT_PUSH_BACKOFF_S[transient_attempts]
                 transient_attempts += 1
+                print("Upload was interrupted. Waiting for the registry to finish the last layer...")
                 print(
-                    f"Push interrupted ({exc}); retrying the same repository "
-                    f"({transient_attempts}/3)..."
+                    f"Retrying in {wait}s "
+                    f"({transient_attempts}/{len(_TRANSIENT_PUSH_BACKOFF_S)})..."
                 )
+                time.sleep(wait)
                 continue
             print(str(exc))
             return None
@@ -205,30 +293,54 @@ def poll_deployment_until_terminal(
     *,
     timeout_s: float = _DEFAULT_TIMEOUT_S,
     client: Optional[SocaityBackendClient] = None,
+    printer=print,
+    sleep=time.sleep,
+    now=time.monotonic,
 ) -> Optional[Dict[str, Any]]:
     """Poll pipeline status until live or a terminal failure."""
     client = client or SocaityBackendClient()
-    deadline = time.monotonic() + timeout_s
+    deadline = now() + timeout_s
     last_status: Optional[Dict[str, Any]] = None
+    last_step: Optional[str] = None
+    last_detail: Optional[str] = None
+    last_print_at = now()
+    saw_progress = False
 
-    while time.monotonic() < deadline:
+    while now() < deadline:
         status = client.get_deployment_pipeline_status(deployment_id)
         if status is None:
-            print("Pipeline status poll failed; retrying...")
-            time.sleep(_POLL_INTERVAL_S)
+            printer("Could not check progress. Retrying...")
+            sleep(_POLL_INTERVAL_S)
             continue
 
         last_status = status
-        phase = status.get("phase")
         state = str(status.get("status", "")).lower()
-        label = f"{state}" + (f" ({phase})" if phase else "")
-        print(f"  deployment status: {label}")
-
         if state in _TERMINAL_STATUSES:
             return status
-        time.sleep(_POLL_INTERVAL_S)
 
-    print(f"Timed out after {int(timeout_s)}s waiting for deployment {deployment_id}.")
+        step, detail = progress_lines(status)
+        if step != last_step:
+            printer(f"  {step}")
+            last_step = step
+            last_detail = None
+            last_print_at = now()
+            saw_progress = True
+        if detail and detail != last_detail and detail != step:
+            printer(f"    {detail}")
+            last_detail = detail
+            last_print_at = now()
+            saw_progress = True
+        elif saw_progress and now() - last_print_at >= 60:
+            printer("    Still working...")
+            last_print_at = now()
+
+        sleep(_POLL_INTERVAL_S)
+
+    minutes = max(1, int(timeout_s) // 60)
+    printer(
+        f"Timed out after {minutes} minute{'s' if minutes != 1 else ''}. "
+        "Check the service page or try deploying again."
+    )
     return last_status
 
 
@@ -244,6 +356,9 @@ def _create_draft_with_prompts(
         return None
     print_analysis_report(report)
 
+    if not apply_gpu_upgrade_if_needed(config, report, assume_yes=assume_yes):
+        return None
+
     if assume_yes:
         resolutions: Dict[str, Optional[str]] = {}
         for model in report.get("models", []):
@@ -263,20 +378,75 @@ def _create_draft_with_prompts(
 
     try:
         draft = client.create_deployment_draft(config, model_resolutions=resolutions)
-    except PrivateSlotLimitError as exc:
-        print(f"\n{exc}")
-        print("Tip: publish a private service from the service page, or upgrade your plan.")
+    except BackendApiError as exc:
+        if getattr(exc, "code", None) == "GPU_UPGRADE_AVAILABLE":
+            print(f"\n{exc}")
+            print("Confirm the larger GPU in analyze, or change gpu_vram_gb, then retry.")
+            return None
+        if getattr(exc, "code", None) == "AUTO_RECHARGE_REQUIRED":
+            print(f"\n{exc}")
+            print(
+                "Enable auto-recharge and save a card on Billing. "
+                "If a previous draft failed, delete that unused private service in My Services, then retry."
+            )
+            return None
+        if isinstance(exc, PrivateSlotLimitError):
+            print(f"\n{exc}")
+            print("Tip: publish a private service from the service page, or upgrade your plan.")
+            raise
         raise
     if draft is None:
         print("Draft creation failed.")
         return None
-    print(
-        f"Draft created: service_id={draft.get('service_id')} "
-        f"deployment_id={draft.get('deployment_id')}"
-    )
+    print("Draft created. Next we will upload your image and start the service.")
+    print(f"  Resume later with: socaity deploy --resume {draft.get('deployment_id')}")
     return draft
 
 
+def _print_failure_and_maybe_delete(
+    client: SocaityBackendClient,
+    deployment_id: str,
+    status: Optional[Dict[str, Any]],
+    *,
+    assume_yes: bool,
+) -> None:
+    """Show why the deploy failed, then delete when asked (or with --yes)."""
+    snapshot = dict(status) if isinstance(status, dict) else {}
+    if not snapshot.get("error") and not snapshot.get("logs"):
+        fresh = client.get_deployment_pipeline_status(deployment_id)
+        if isinstance(fresh, dict):
+            snapshot = fresh
+    state = str(snapshot.get("status") or "").lower()
+    print(f"\n{humanize_failure(snapshot.get('error'), state)}")
+    logs = snapshot.get("logs")
+    if logs:
+        print("\nLogs:")
+        for line in str(logs).splitlines():
+            print(f"  {line}")
+    else:
+        detail = support_detail(snapshot.get("error"))
+        if detail:
+            print(f"  Details: {detail}")
+    if assume_yes:
+        deleted = client.cancel_deployment_pipeline(deployment_id)
+        if deleted is None:
+            print("Could not delete the failed service. Delete it from My Services.")
+            print(f"  {service_page_url(snapshot.get('service_id'))}")
+            return
+        print("Deleted the failed service.")
+        return
+    print("This failed service is on My Services and still uses a private slot.")
+    if not input_yes_no("Delete this failed service now?", default=False):
+        print(f"  {service_page_url(snapshot.get('service_id'))}")
+        return
+    deleted = client.cancel_deployment_pipeline(deployment_id)
+    if deleted is None:
+        print("Could not delete the failed service. Delete it from My Services.")
+        print(f"  {service_page_url(snapshot.get('service_id'))}")
+        return
+    print("Deleted the failed service.")
+
+
 def run_full_deploy(
     config: Dict[str, Any],
     *,
@@ -292,19 +462,20 @@ def run_full_deploy(
     if deployment_id:
         status = client.get_deployment_pipeline_status(deployment_id)
         if status is None:
-            print(f"Deployment {deployment_id} not found or not accessible.")
+            print("That deployment was not found, or you do not have access to it.")
             return None
         state = str(status.get("status", "")).lower()
         if state == "live":
-            print(f"Deployment {deployment_id} is already live.")
+            print("This service is already live.")
+            if status.get("service_id"):
+                print(f"  {service_page_url(status.get('service_id'))}")
             return status
         if state in _TERMINAL_STATUSES - {"live"}:
-            print(
-                f"Deployment {deployment_id} is in terminal state '{state}'. "
-                "Create a new draft or fix the issue before resuming."
+            _print_failure_and_maybe_delete(
+                client, deployment_id, status, assume_yes=assume_yes,
             )
             return status
-        print(f"Resuming deployment {deployment_id} (status={state}).")
+        print("Continuing your deployment...")
     else:
         draft = _create_draft_with_prompts(config, client=client, assume_yes=assume_yes)
         if draft is None:
@@ -317,37 +488,45 @@ def run_full_deploy(
     current = client.get_deployment_pipeline_status(deployment_id) or {}
     state = str(current.get("status", "")).lower()
     if state in {"draft", "awaiting_image", "pushing", "failed_push"}:
-        print(f"Pushing image '{local_tag}' to the Socaity registry...")
+        print("Uploading your image...")
         digest = push_image_to_registry(deployment_id, local_tag, client=client)
         if digest is None:
+            _print_failure_and_maybe_delete(
+                client, deployment_id, current, assume_yes=assume_yes,
+            )
             return None
         size_bytes = image_size_bytes(local_tag)
         pushed = client.confirm_image_pushed(deployment_id, digest=digest, size_bytes=size_bytes)
         if pushed is None:
-            print("Backend did not accept the image push confirmation.")
+            print("The server did not accept the uploaded image. Please try again.")
+            _print_failure_and_maybe_delete(
+                client, deployment_id, current, assume_yes=assume_yes,
+            )
             return None
-        print(f"Image pushed (digest={digest}). Validation and provisioning started.")
+        print("Image uploaded. Checking it and starting your service...")
     elif state in {"validating", "promoting", "provisioning"}:
-        print(f"Image already pushed; waiting for pipeline (status={state}).")
+        print("Image already uploaded. Checking it and starting your service...")
     elif state == "live":
-        print(f"Deployment {deployment_id} is already live.")
+        print("This service is already live.")
+        if current.get("service_id"):
+            print(f"  {service_page_url(current.get('service_id'))}")
         return current
 
-    print("Waiting for deployment to go live (this may take several minutes)...")
+    print("This can take several minutes.")
     final = poll_deployment_until_terminal(deployment_id, client=client)
     if final is None:
         return None
 
     final_state = str(final.get("status", "")).lower()
     if final_state == "live":
-        print(f"\nDeployment live: deployment_id={deployment_id}")
-        if final.get("service_id"):
-            print(f"  service_id={final['service_id']}")
-        print("  https://www.socaity.ai")
-    elif final.get("error"):
-        print(f"\nDeployment failed: {final['error']}")
-    else:
-        print(f"\nDeployment ended with status={final_state}.")
+        print("\nYour service is live.")
+        print(f"  {service_page_url(final.get('service_id'))}")
+        return final
+    if final_state in _TERMINAL_STATUSES:
+        _print_failure_and_maybe_delete(
+            client, deployment_id, final, assume_yes=assume_yes,
+        )
+        return final
     return final
 
 

{socaity_cli-0.1.5 → socaity_cli-0.1.7}/socaity_cli/errors.py

@@ -33,3 +33,10 @@ class PrivateSlotLimitError(BackendApiError):
             "Publish an existing private service or upgrade your plan to free a slot."
         )
         super().__init__(403, message, code="PRIVATE_SLOT_LIMIT", detail=detail)
+
+
+class RegistryQuotaExceededError(BackendApiError):
+    """Harbor image quota would be exceeded by this push."""
+
+    def __init__(self, message: str, *, detail: Any = None):
+        super().__init__(413, message, code="REGISTRY_QUOTA_EXCEEDED", detail=detail)

{socaity_cli-0.1.5 → socaity_cli-0.1.7}/socaity_cli/http.py

@@ -6,7 +6,7 @@ from typing import Any, Dict, Optional
 import httpx
 
 from socaity_cli.credentials import DEFAULT_BACKEND_URL, get_api_key
-from socaity_cli.errors import BackendApiError, PrivateSlotLimitError
+from socaity_cli.errors import BackendApiError, PrivateSlotLimitError, RegistryQuotaExceededError
 
 
 class BackendHttp:
@@ -30,6 +30,14 @@ class BackendHttp:
         detail = body.get("detail") if isinstance(body, dict) else None
         if isinstance(detail, dict) and detail.get("code") == "PRIVATE_SLOT_LIMIT":
             raise PrivateSlotLimitError(detail)
+        if status_code == 413:
+            if isinstance(detail, str) and detail.strip():
+                message = detail.strip()
+            elif isinstance(detail, dict):
+                message = str(detail.get("message") or detail)
+            else:
+                message = (body_text or "Registry quota exceeded.")[:300]
+            raise RegistryQuotaExceededError(message, detail=detail)
         if isinstance(detail, dict) and detail.get("code"):
             raise BackendApiError(
                 status_code,
@@ -64,7 +72,7 @@ class BackendHttp:
             self._raise_for_structured_error(response.status_code, response.text)
             print(f"Request to {path} failed with status {response.status_code}: {response.text[:300]}")
             return None
-        except (PrivateSlotLimitError, BackendApiError):
+        except (PrivateSlotLimitError, RegistryQuotaExceededError, BackendApiError):
             raise
         except Exception as e:
             print(f"Request to {path} failed: {e}")

{socaity_cli-0.1.5 → socaity_cli-0.1.7}/socaity_cli/registry_push.py

@@ -1,15 +1,19 @@
-"""Docker push with ephemeral registry credentials.
+"""Push a local image to the Socaity registry with ephemeral credentials.
 
-Credentials live only in a throwaway DOCKER_CONFIG directory that is deleted
-after the push, so nothing persists in the user's ~/.docker/config.json.
+Prefers ``skopeo`` (long command timeout, serial layers, built-in retries).
+Docker 29's ``docker push`` uses a short ResponseHeaderTimeout and aborts
+Harbor commits that later succeed. Credentials never land in ~/.docker.
 """
 from __future__ import annotations
 
+import base64
 import json
 import os
 import re
+import shutil
 import subprocess
 import tempfile
+from pathlib import Path
 from typing import Optional, Tuple
 
 _DIGEST_RE = re.compile(r"digest:\s*(sha256:[0-9a-f]{64})")
@@ -21,6 +25,8 @@ _TRANSIENT_PUSH_MARKERS = (
     "tls handshake",
     "unexpected eof",
 )
+_SKOPEO_TIMEOUT = os.environ.get("SOCAITY_PUSH_TIMEOUT", "2h")
+_SKOPEO_RETRIES = int(os.environ.get("SOCAITY_PUSH_RETRIES", "20"))
 
 
 class DockerNotAvailable(RuntimeError):
@@ -41,6 +47,44 @@ def is_transient_push_error(message: str) -> bool:
     return any(marker in lower for marker in _TRANSIENT_PUSH_MARKERS)
 
 
+def daemon_ref(local_tag: str) -> str:
+    """``docker-daemon:`` reference; add ``:latest`` when the tag is omitted."""
+    name = local_tag.strip()
+    if not name:
+        raise PushFailed("Local image tag is empty.")
+    if ":" not in name.rsplit("/", 1)[-1]:
+        return f"{name}:latest"
+    return name
+
+
+def _skopeo_copy_args(
+    *,
+    src: str,
+    dest: str,
+    authfile: str,
+    digestfile: str,
+) -> list:
+    return [
+        "skopeo",
+        f"--command-timeout={_SKOPEO_TIMEOUT}",
+        "copy",
+        "--dest-tls-verify=true",
+        f"--dest-authfile={authfile}",
+        "--image-parallel-copies=1",
+        f"--retry-times={_SKOPEO_RETRIES}",
+        "--retry-delay=15s",
+        "--dest-precompute-digests",
+        f"--digestfile={digestfile}",
+        src,
+        dest,
+    ]
+
+
+def _write_authfile(path: str, registry: str, username: str, password: str) -> None:
+    token = base64.b64encode(f"{username}:{password}".encode()).decode()
+    Path(path).write_text(json.dumps({"auths": {registry: {"auth": token}}}))
+
+
 def _push_command(ref: str) -> list:
     """``docker push`` args. Docker 25+ dropped ``--max-concurrent-uploads``."""
     help_out = _docker(["push", "--help"])
@@ -78,7 +122,7 @@ def push_image(
     password: str,
     local_tag: str,
 ) -> Tuple[str, int]:
-    """Tag ``local_tag`` and push it as ``registry/repository:tag``.
+    """Copy ``local_tag`` to ``registry/repository:tag``.
 
     Returns:
         (manifest digest reported by the registry, local image size in bytes).
@@ -86,20 +130,94 @@ def push_image(
     Raises:
         DockerNotAvailable, CredentialsExpired, PushFailed.
     """
-    ref = f"{registry}/{repository}:{tag}"
     size = image_size_bytes(local_tag)
     if size == 0:
         raise PushFailed(f"Local image '{local_tag}' not found. Build it first (apipod build).")
 
-    result = _docker(["tag", local_tag, ref])
+    dest = f"{registry}/{repository}:{tag}"
+    if shutil.which("skopeo"):
+        print(
+            f"  Pushing with skopeo ({_SKOPEO_TIMEOUT} timeout, one layer at a time, "
+            f"{_SKOPEO_RETRIES} retries)..."
+        )
+        return _push_with_skopeo(
+            registry=registry,
+            dest=dest,
+            username=username,
+            password=password,
+            local_tag=local_tag,
+            size=size,
+        )
+    print("  skopeo not found; falling back to docker push (short Harbor header timeout).")
+    return _push_with_docker(
+        registry=registry,
+        dest=dest,
+        username=username,
+        password=password,
+        local_tag=local_tag,
+        size=size,
+    )
+
+
+def _push_with_skopeo(
+    *,
+    registry: str,
+    dest: str,
+    username: str,
+    password: str,
+    local_tag: str,
+    size: int,
+) -> Tuple[str, int]:
+    src = f"docker-daemon:{daemon_ref(local_tag)}"
+    dest_ref = f"docker://{dest}"
+    with tempfile.TemporaryDirectory(prefix="socaity-skopeo-") as tmp:
+        authfile = os.path.join(tmp, "auth.json")
+        digestfile = os.path.join(tmp, "digest")
+        _write_authfile(authfile, registry, username, password)
+        cmd = _skopeo_copy_args(src=src, dest=dest_ref, authfile=authfile, digestfile=digestfile)
+        try:
+            push = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        except FileNotFoundError as exc:
+            raise PushFailed("skopeo disappeared from PATH during the push.") from exc
+        last_lines = []
+        for line in push.stdout:
+            line = line.rstrip()
+            last_lines = (last_lines + [line])[-8:]
+            if line:
+                print(f"  {line}")
+        push.wait()
+        tail = " | ".join(last_lines)
+        if push.returncode != 0:
+            if "unauthorized" in tail.lower() or "401" in tail.lower() or "authentication required" in tail.lower():
+                raise CredentialsExpired("Push rejected mid-transfer; the credentials expired.")
+            raise PushFailed(f"skopeo copy failed: {tail[:400]}")
+        digest = Path(digestfile).read_text().strip() if os.path.exists(digestfile) else ""
+        if not digest.startswith("sha256:"):
+            raise PushFailed("skopeo copy succeeded but no digest file was written.")
+        return digest, size
+
+
+def _push_with_docker(
+    *,
+    registry: str,
+    dest: str,
+    username: str,
+    password: str,
+    local_tag: str,
+    size: int,
+) -> Tuple[str, int]:
+    result = _docker(["tag", local_tag, dest])
     if result.returncode != 0:
         raise PushFailed(f"docker tag failed: {result.stderr.decode()[:300]}")
 
     with tempfile.TemporaryDirectory(prefix="socaity-push-") as docker_config:
         env = {**os.environ, "DOCKER_CONFIG": docker_config}
         try:
-            login = _docker(["login", registry, "-u", username, "--password-stdin"],
-                            env=env, input_bytes=password.encode())
+            login = _docker(
+                ["login", registry, "-u", username, "--password-stdin"],
+                env=env,
+                input_bytes=password.encode(),
+            )
             if login.returncode != 0:
                 stderr = login.stderr.decode()
                 if "unauthorized" in stderr.lower() or "401" in stderr:
@@ -107,8 +225,11 @@ def push_image(
                 raise PushFailed(f"docker login failed: {stderr[:300]}")
 
             push = subprocess.Popen(
-                _push_command(ref),
-                stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env, text=True,
+                _push_command(dest),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                env=env,
+                text=True,
             )
             digest, last_lines = None, []
             for line in push.stdout:
@@ -126,12 +247,12 @@ def push_image(
                     raise CredentialsExpired("Push rejected mid-transfer; the credentials expired.")
                 raise PushFailed(f"docker push failed: {tail[:400]}")
             if not digest:
-                digest = _digest_from_local_metadata(ref, env)
+                digest = _digest_from_local_metadata(dest, env)
             if not digest:
                 raise PushFailed("Push succeeded but no digest was reported by the registry.")
             return digest, size
         finally:
-            _docker(["rmi", ref], env=env)  # remove the extra tag, keep the local image
+            _docker(["rmi", dest], env=env)
 
 
 def _digest_from_local_metadata(ref: str, env: dict) -> Optional[str]:

{socaity_cli-0.1.5 → socaity_cli-0.1.7}/socaity_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: socaity-cli
-Version: 0.1.5
+Version: 0.1.7
 Summary: Socaity platform CLI: login, catalog browsing, SDK installs and APIPod deployment commands.
 Author: SocAIty
 License: MIT

{socaity_cli-0.1.5 → socaity_cli-0.1.7}/socaity_cli.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ socaity_cli/auth.py
 socaity_cli/backend_client.py
 socaity_cli/cli.py
 socaity_cli/credentials.py
+socaity_cli/deploy_messages.py
 socaity_cli/deployment.py
 socaity_cli/errors.py
 socaity_cli/http.py

{socaity_cli-0.1.5 → socaity_cli-0.1.7}/test/test_registry_push.py

@@ -1,4 +1,9 @@
-from socaity_cli.registry_push import _push_command, is_transient_push_error
+from socaity_cli.registry_push import (
+    _push_command,
+    _skopeo_copy_args,
+    daemon_ref,
+    is_transient_push_error,
+)
 
 
 def test_is_transient_push_error_matches_harbor_timeouts():
@@ -30,3 +35,25 @@ def test_push_command_uses_max_concurrent_when_supported(monkeypatch):
     assert _push_command("harbor.example/repo:tag") == [
         "docker", "push", "--max-concurrent-uploads=1", "harbor.example/repo:tag",
     ]
+
+
+def test_daemon_ref_adds_latest():
+    assert daemon_ref("apipod-qwen38") == "apipod-qwen38:latest"
+    assert daemon_ref("apipod-qwen38:latest") == "apipod-qwen38:latest"
+    assert daemon_ref("ghcr.io/org/app:v1") == "ghcr.io/org/app:v1"
+
+
+def test_skopeo_copy_args_are_serial_with_long_timeout():
+    args = _skopeo_copy_args(
+        src="docker-daemon:app:latest",
+        dest="docker://harbor.example/repo:tag",
+        authfile="/tmp/auth.json",
+        digestfile="/tmp/digest",
+    )
+    assert args[0] == "skopeo"
+    assert args[1] == "--command-timeout=2h"
+    assert "--image-parallel-copies=1" in args
+    assert "--retry-times=20" in args
+    assert "--dest-precompute-digests" in args
+    assert "docker-daemon:app:latest" in args
+    assert "docker://harbor.example/repo:tag" in args