amina-cli 0.4.0__tar.gz → 0.4.2__tar.gz

{amina_cli-0.4.0 → amina_cli-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amina-cli
-Version: 0.4.0
+Version: 0.4.2
 Summary: CLI for AminoAnalytica protein engineering platform
 Project-URL: Homepage, https://aminoanalytica.com
 Project-URL: Documentation, https://docs.aminoanalytica.com

{amina_cli-0.4.0 → amina_cli-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "amina-cli"
-version = "0.4.0"
+version = "0.4.2"
 description = "CLI for AminoAnalytica protein engineering platform"
 readme = "README.md"
 license = {text = "Apache-2.0"}

{amina_cli-0.4.0 → amina_cli-0.4.2}/src/amina_cli/__init__.py

@@ -9,4 +9,4 @@ Quick start:
     amina run esmfold --sequence "MKFLILLFNILCLFPVLAADNH"
 """
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"

{amina_cli-0.4.0 → amina_cli-0.4.2}/src/amina_cli/commands/jobs_cmd.py

@@ -824,7 +824,10 @@ def _find_submission_files(root: Path, recursive: bool) -> list[tuple[str, Path]
 
     Returns a list of ``(job_id, dir_containing_submission)`` tuples. Files
     that fail to parse or lack a ``job_id`` field are skipped silently — they
-    weren't written by ``amina run --background``.
+    correspond to runs that aborted before the gateway returned (submit error,
+    interrupt, network failure), leaving the up-front input record without
+    any job-tracking fields ever being merged in. There is no server-side
+    job to reconcile in those cases.
     """
     pattern = "**/submission.json" if recursive else "*/submission.json"
     found: list[tuple[str, Path]] = []
@@ -955,19 +958,20 @@ def reconcile(
             per_job.append(entry)
             continue
 
-        local_status = job_info.get("status", "")
-        if local_status not in TERMINAL_STATUSES:
-            # Local cache (now fresh) says this job hasn't terminated yet.
-            # Don't waste a per-job HTTP roundtrip just to confirm.
-            summary["still_running"] += 1
-            entry["action"] = "still_running"
-            entry["status"] = local_status
-            per_job.append(entry)
-            continue
-
-        # Terminal: fetch the full payload (signed_urls, output_files) so the
-        # response.json we write matches the shape `amina jobs download`
-        # produces.
+        # Always go to the server for the truth, even if the local cache says
+        # non-terminal. Reason: the bulk /list_jobs refresh above can return
+        # stale data when the worker's completion callback dropped (Supabase
+        # blip, gateway crash mid-handler) — a 300-job campaign reported 197
+        # jobs still_running while all 300 had finished on Modal. The CLI
+        # used to early-return on local non-terminal status, which made this
+        # bug unrecoverable from the client. Now reconcile mirrors what
+        # `amina jobs status` does: ask Modal directly via call_id.
+        #
+        # Cost: O(pending) HTTP calls per cycle. Bounded by jobs the user is
+        # actively waiting on (response.json-present dirs short-circuit
+        # above), and the gateway's heal-on-read upgrade makes the post-merge
+        # local cache mostly fresh anyway, so this fall-through is rarely hit
+        # in practice. It exists as a defence-in-depth for gateway brownouts.
         try:
             status_result = _resolve_job_status(job_info)
         except ToolExecutionError as fetch_err:
@@ -978,6 +982,15 @@ def reconcile(
             continue
         _persist_terminal_status(job_info, status_result)
 
+        if not status_result.get("terminal", False) and status_result.get("status") not in TERMINAL_STATUSES:
+            # Genuinely still running on the server. Count, record the
+            # FRESH status (not the stale-cache one we started with), move on.
+            summary["still_running"] += 1
+            entry["action"] = "still_running"
+            entry["status"] = status_result.get("status", "running")
+            per_job.append(entry)
+            continue
+
         # Build the response payload. For completed jobs the gateway hands us
         # a full `result` dict (output_files, signed_urls, data, ...). For
         # failed/cancelled jobs Modal often returns only an error string with

{amina_cli-0.4.0 → amina_cli-0.4.2}/src/amina_cli/commands/tools/__init__.py

@@ -8,6 +8,7 @@ Each tool file exports METADATA dict and register() function.
 import importlib
 import json
 import os
+import sys
 from pathlib import Path
 from typing import Iterator, Optional
 import typer
@@ -15,6 +16,7 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
 
+from amina_cli import __version__ as _CLI_VERSION
 from amina_cli.commands.tools.display import render_tool_output
 
 console = Console()
@@ -23,6 +25,17 @@ console = Console()
 err_console = Console(stderr=True)
 
 
+def _reproducibility_fields() -> dict:
+    """Fields recorded in submission.json so a run can be re-executed exactly.
+
+    ``argv`` is the literal ``sys.argv`` of the current process — the user's
+    command-line invocation, preserved as a list. ``cli_version`` pins the
+    amina-cli version that built the request, so future readers can match the
+    parameter shape against the release that produced it.
+    """
+    return {"cli_version": _CLI_VERSION, "argv": list(sys.argv)}
+
+
 def _is_truthy_env(name: str) -> bool:
     """Standard env-var boolean read.
 
@@ -124,6 +137,11 @@ def run_tool_with_progress(
         console.print("[red]Error:[/red] --output / -o is required")
         raise typer.Exit(1)
 
+    # Snapshot once at function entry so the early and late submission.json
+    # writes agree on argv even if a caller (e.g. tests) mutates sys.argv
+    # mid-run.
+    repro = _reproducibility_fields()
+
     # Handle background submission
     if background:
         # Resolved before the try so error handlers can route to stderr
@@ -135,6 +153,20 @@ def run_tool_with_progress(
             tool_info = get_tool(tool_name)
             display_name = tool_info.get("display_name", tool_name) if tool_info else tool_name
 
+            # Early submission.json write — before any network call — so a
+            # reproducibility record exists even if submission fails (auth,
+            # credits, validation, network). Overwritten below with the
+            # augmented record once submit_tool_sync returns successfully.
+            output_dir.mkdir(parents=True, exist_ok=True)
+            submission_path = output_dir / "submission.json"
+            submission_path.write_text(
+                json.dumps(
+                    {"tool_name": tool_name, "params": params, **repro},
+                    indent=2,
+                    default=str,
+                )
+            )
+
             if json_mode:
                 # No spinner output to stdout when the caller wants JSON.
                 result = submit_tool_sync(tool_name, params)
@@ -147,13 +179,30 @@ def run_tool_with_progress(
                     progress.add_task(f"Submitting {display_name}...", total=None)
                     result = submit_tool_sync(tool_name, params)
 
-            # Save to local job history
-            save_job(result)
-
-            # Persist the structured submission payload for downstream agents/scripts
-            output_dir.mkdir(parents=True, exist_ok=True)
-            submission_path = output_dir / "submission.json"
-            submission_path.write_text(json.dumps(result, indent=2, default=str))
+            # Save to local job history. Soft-fail on filesystem errors —
+            # the job is already submitted and being billed, so a stale
+            # local cache must not surface as a traceback that hides the
+            # job_id from the user.
+            warn_console = err_console if json_mode else console
+            try:
+                save_job(result)
+            except OSError as e:
+                warn_console.print(f"[yellow]Warning:[/yellow] Could not update local job history: {e}")
+
+            # Overwrite submission.json with the augmented record: input fields
+            # from the early write, plus the gateway tracking fields returned
+            # by submit_tool_sync (job_id, call_id, status, etc.). Soft-fail
+            # for the same reason as save_job above.
+            submission_record = {
+                "tool_name": tool_name,
+                "params": params,
+                **repro,
+                **result,
+            }
+            try:
+                submission_path.write_text(json.dumps(submission_record, indent=2, default=str))
+            except OSError as e:
+                warn_console.print(f"[yellow]Warning:[/yellow] Could not write {submission_path}: {e}")
 
             if json_mode:
                 # Single-line JSON on stdout; nothing else, ever, in this branch.
@@ -276,6 +325,20 @@ def run_tool_with_progress(
         tool_info = get_tool(tool_name)
         display_name = tool_info.get("display_name", tool_name) if tool_info else tool_name
 
+        # Persist a reproducibility record up-front: written before submission so
+        # the user-facing inputs, CLI version, and argv survive mid-run failures,
+        # interrupts, or network errors. response.json (written after the run)
+        # captures the result side.
+        output_dir.mkdir(parents=True, exist_ok=True)
+        submission_path = output_dir / "submission.json"
+        submission_path.write_text(
+            json.dumps(
+                {"tool_name": tool_name, "params": params, **repro},
+                indent=2,
+                default=str,
+            )
+        )
+
         # Track queue position for progress updates
         queue_position_holder = {"position": 0, "is_queued": False}
 
@@ -337,9 +400,28 @@ def run_tool_with_progress(
 
             # Persist the structured response payload (success or failure) so agents
             # and scripts can read metrics/warnings/cost without re-parsing stdout.
-            output_dir.mkdir(parents=True, exist_ok=True)
+            # Soft-fail on filesystem errors — the job has already run and been
+            # billed, so a disk hiccup must not surface as a traceback.
             response_path = output_dir / "response.json"
-            response_path.write_text(json.dumps(result, indent=2, default=str))
+            try:
+                response_path.write_text(json.dumps(result, indent=2, default=str))
+            except OSError as e:
+                console.print(f"[yellow]Warning:[/yellow] Could not write {response_path}: {e}")
+
+            # Overwrite submission.json with the augmented record. Spreading
+            # **result mirrors the background path so consumers see the same
+            # shape on both, and the status field reflects what the worker
+            # actually reported. Soft-fail for the same reason as response.json.
+            submission_record = {
+                "tool_name": tool_name,
+                "params": params,
+                **repro,
+                **result,
+            }
+            try:
+                submission_path.write_text(json.dumps(submission_record, indent=2, default=str))
+            except OSError as e:
+                console.print(f"[yellow]Warning:[/yellow] Could not write {submission_path}: {e}")
 
         _display_result(result, downloaded, output_dir, params, tool_info, response_path)