blobhub-cli 0.2.0__tar.gz → 0.4.0__tar.gz

{blobhub_cli-0.2.0 → blobhub_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: blobhub-cli
-Version: 0.2.0
+Version: 0.4.0
 Summary: BlobHub command line interface — work with blobs, revisions, and their contents from the terminal
 Project-URL: Homepage, https://blobhub.io/
 Project-URL: Documentation, https://docs.blobhub.io/
@@ -151,7 +151,7 @@ my-project/
 type: workflow_blob_deployment
 version: "1.0"
 blob: acme-corp/checkout                # <org>/<blob>, or a bare <blob> plus --org/BLOBHUB_ORG
-revision: latest                        # or a pinned revision UUID
+revision: default                       # the blob's default revision, or a pinned revision UUID
 definitions:
   - alias: checkout_flow
     source: definitions/checkout_flow.json

{blobhub_cli-0.2.0 → blobhub_cli-0.4.0}/README.md

@@ -98,7 +98,7 @@ my-project/
 type: workflow_blob_deployment
 version: "1.0"
 blob: acme-corp/checkout                # <org>/<blob>, or a bare <blob> plus --org/BLOBHUB_ORG
-revision: latest                        # or a pinned revision UUID
+revision: default                       # the blob's default revision, or a pinned revision UUID
 definitions:
   - alias: checkout_flow
     source: definitions/checkout_flow.json

{blobhub_cli-0.2.0 → blobhub_cli-0.4.0}/src/blobhub_cli/__init__.py

@@ -5,4 +5,4 @@ Contract: this module is the sole source of the package version — hatchling re
 Invariant: no other file in this package defines `__version__`.
 """
 
-__version__ = "0.2.0"
+__version__ = "0.4.0"

{blobhub_cli-0.2.0 → blobhub_cli-0.4.0}/src/blobhub_cli/api/client.py

@@ -3,11 +3,10 @@
 Contract: `get`, `query`, `command`, and `raw_query` route every response through `_handle`,
 which maps HTTP status and the body's `status` field onto the `api.errors` hierarchy;
 `raw_query` alone skips the status gate, and `probe` skips both the gate and the retry loop.
-`query`/`command`/`raw_query` take a required keyword-only `engine` -- the engine a data request
-targets is the caller's to supply, never this class's to assume, because one command can
-legitimately span both: a scheduler `deploy` writes schedules against `scheduler_blobhub` and
-validates its targets with `workflow_blobhub` calls against the target revision, so a client
-fixed to one engine could not do that.
+Neither `query`, `command`, nor `raw_query` names which component serves a data-channel call --
+the target revision's blob type decides that server-side, so there is nothing for a caller to
+supply here at all, even for a scheduler `deploy` that legitimately writes schedules against one
+blob and validates its targets against another.
 Invariant: `Content-Type: application/json` is sent on every request, and the API key is
 never logged, echoed, or included in any exception message. This module is the only one that
 performs I/O against the BlobHub API -- the single sanctioned exception elsewhere is `doctor`'s
@@ -28,9 +27,6 @@ from blobhub_cli.api.errors import (
     ApiTransientError,
 )
 
-WORKFLOW_ENGINE = "workflow_blobhub"
-SCHEDULER_ENGINE = "scheduler_blobhub"
-
 _TRANSIENT = (ApiRateLimited, ApiTransientError, ApiNetworkError)
 _ATTEMPTS = 3
 _BASE_DELAY = 0.5
@@ -61,8 +57,12 @@ class Client:
     def __exit__(self, *exc_info: object) -> None:
         self._http.close()
 
-    def get(self, path: str) -> dict:
-        return self._send("GET", path, gate_status=True)
+    def get(self, path: str, params: dict[str, object] | None = None) -> dict:
+        # A `None` entry is dropped rather than sent: the paged routes validate their query
+        # parameters instead of ignoring them, so `?limit=` or `?cursor=None` is a 400.
+        if params is not None:
+            params = {key: value for key, value in params.items() if value is not None}
+        return self._send("GET", path, gate_status=True, params=params or None)
 
     def probe(self, path: str = "/users/me") -> tuple[int, float]:
         """One unretried request, returning (status_code, elapsed_ms) without gating the body.
@@ -78,20 +78,20 @@ class Client:
             raise ApiNetworkError(str(exc)) from exc
         return resp.status_code, (time.monotonic() - start) * 1000
 
-    def query(self, revision_id: str, command: str, *, engine: str, **args: object) -> dict:
-        return self._data_request(revision_id, "query", command, engine=engine, gate_status=True, **args)
+    def query(self, revision_id: str, command: str, **args: object) -> dict:
+        return self._data_request(revision_id, "query", command, gate_status=True, **args)
 
-    def command(self, revision_id: str, command: str, *, engine: str, **args: object) -> dict:
-        return self._data_request(revision_id, "command", command, engine=engine, gate_status=True, **args)
+    def command(self, revision_id: str, command: str, **args: object) -> dict:
+        return self._data_request(revision_id, "command", command, gate_status=True, **args)
 
-    def raw_query(self, revision_id: str, command: str, *, engine: str, **args: object) -> dict:
-        return self._data_request(revision_id, "query", command, engine=engine, gate_status=False, **args)
+    def raw_query(self, revision_id: str, command: str, **args: object) -> dict:
+        return self._data_request(revision_id, "query", command, gate_status=False, **args)
 
     def _data_request(
-        self, revision_id: str, channel: str, command: str, *, engine: str, gate_status: bool, **args: object
+        self, revision_id: str, channel: str, command: str, *, gate_status: bool, **args: object
     ) -> dict:
         path = f"/revisions/{revision_id}/data/{channel}"
-        body = {"engine": engine, "command": command, **args}
+        body = {"command": command, **args}
         return self._send("POST", path, gate_status=gate_status, json=body)
 
     def _send(self, method: str, path: str, *, gate_status: bool, **kwargs: object) -> dict:

{blobhub_cli-0.2.0 → blobhub_cli-0.4.0}/src/blobhub_cli/api/commands.py

@@ -1,4 +1,4 @@
-"""Typed wrappers over `Client`, one method per platform read or engine command.
+"""Typed wrappers over `Client`, one method per platform read or data-channel command.
 
 Contract: each method sends exactly one request and returns only the envelope key(s) the
 platform documents for that command, adding no caching, retries, or aggregation of its own.
@@ -7,7 +7,7 @@ Invariant: `create_definition` includes `layout` in the request body only when i
 400 for a workflow-category definition, which never has a `layout` field.
 """
 
-from blobhub_cli.api.client import SCHEDULER_ENGINE, WORKFLOW_ENGINE, Client
+from blobhub_cli.api.client import Client
 
 
 class Api:
@@ -26,41 +26,45 @@ class Api:
     def get_revision(self, revision_id: str) -> dict:
         return self._client.get(f"/revisions/{revision_id}")["revision"]
 
-    def list_revisions(self, org: str, blob: str) -> list[dict]:
-        return self._client.get(f"/blobs/{org}/{blob}/revisions")["revisions"]
+    def resolve_revision(self, org: str, blob: str, ref: str) -> dict:
+        # `ref` is a revision id or the literal `default`. Unlike `get_revision`, this route resolves
+        # the ref *within the blob*, so a revision id belonging to another blob answers the same 404
+        # as one that does not exist -- which `/revisions/{id}` cannot do, having no blob in its path.
+        return self._client.get(f"/blobs/{org}/{blob}/revisions/{ref}")["revision"]
+
+    def list_revisions(
+        self, org: str, blob: str, *, limit: int | None = None, cursor: str | None = None
+    ) -> tuple[list[dict], str | None]:
+        # One page and the next cursor -- this method deliberately does not loop, for the reason
+        # list_schedules gives: a loop here would hide the paging from every test that uses it.
+        body = self._client.get(
+            f"/blobs/{org}/{blob}/revisions", {"limit": limit, "cursor": cursor})
+        return body["revisions"], body["cursor"]
 
     def get_blob_limits(self, org: str, blob: str) -> dict:
         return self._client.get(f"/blobs/{org}/{blob}/limits")["limits"]
 
     def list_definitions(self, revision_id: str, category: str) -> list[dict]:
-        return self._client.query(
-            revision_id, "list_definitions", engine=WORKFLOW_ENGINE, category=category
-        )["definitions"]
+        return self._client.query(revision_id, "list_definitions", category=category)["definitions"]
 
     def download_definition(self, revision_id: str, definition_id: str) -> tuple[dict, dict]:
-        body = self._client.query(
-            revision_id, "download_definition", engine=WORKFLOW_ENGINE, definition_id=definition_id
-        )
+        body = self._client.query(revision_id, "download_definition", definition_id=definition_id)
         return body["definition"], body["definition_object"]
 
     def create_definition(self, revision_id: str, alias: str, category: str, layout: dict | None = None) -> dict:
         args: dict[str, object] = {"alias": alias, "category": category}
         if layout is not None:
             args["layout"] = layout
-        return self._client.command(revision_id, "create_definition", engine=WORKFLOW_ENGINE, **args)["definition"]
+        return self._client.command(revision_id, "create_definition", **args)["definition"]
 
     def upload_definition(self, revision_id: str, definition_id: str, document: dict) -> None:
-        self._client.command(
-            revision_id, "upload_definition", engine=WORKFLOW_ENGINE, definition_id=definition_id, definition=document
-        )
+        self._client.command(revision_id, "upload_definition", definition_id=definition_id, definition=document)
 
     def delete_definition(self, revision_id: str, definition_id: str) -> None:
-        self._client.command(revision_id, "delete_definition", engine=WORKFLOW_ENGINE, definition_id=definition_id)
+        self._client.command(revision_id, "delete_definition", definition_id=definition_id)
 
     def check_definition(self, revision_id: str, definition_id: str) -> tuple[str, list[dict]]:
-        body = self._client.raw_query(
-            revision_id, "check_definition", engine=WORKFLOW_ENGINE, definition_id=definition_id
-        )
+        body = self._client.raw_query(revision_id, "check_definition", definition_id=definition_id)
         return body.get("status"), body.get("events", [])
 
     def create_session(self, revision_id: str, *, alias: str | None = None, description: str | None = None) -> dict:
@@ -69,12 +73,12 @@ class Api:
             args["alias"] = alias
         if description is not None:
             args["description"] = description
-        return self._client.command(revision_id, "create_session", engine=WORKFLOW_ENGINE, **args)["session"]
+        return self._client.command(revision_id, "create_session", **args)["session"]
 
     def get_session(self, revision_id: str, session: str) -> dict:
         # Accepts an id OR an alias -- `get_session_by_session_id_or_alias` server-side. Unlike
         # `create_execution`, which resolves the id only (spec §1.1).
-        return self._client.query(revision_id, "get_session", engine=WORKFLOW_ENGINE, session_id=session)["session"]
+        return self._client.query(revision_id, "get_session", session_id=session)["session"]
 
     def create_execution(self, revision_id: str, session_id: str, *, definition_id: str) -> dict:
         # Addressed by id, not alias: `CREATE_EXECUTION_SCHEMA` accepts either, but the server
@@ -84,13 +88,11 @@ class Api:
         # definition -- an alias-addressed execution could resolve to either, unpredictably. The
         # caller already has the id from `load_set`, so there is no reason to take that risk.
         return self._client.command(
-            revision_id, "create_execution", engine=WORKFLOW_ENGINE, session_id=session_id, definition_id=definition_id
+            revision_id, "create_execution", session_id=session_id, definition_id=definition_id
         )["execution"]
 
     def get_execution(self, revision_id: str, execution_id: str) -> dict:
-        return self._client.query(revision_id, "get_execution", engine=WORKFLOW_ENGINE, execution_id=execution_id)[
-            "execution"
-        ]
+        return self._client.query(revision_id, "get_execution", execution_id=execution_id)["execution"]
 
     def list_execution_events(
         self,
@@ -101,16 +103,14 @@ class Api:
         ascending: bool = True,
         limit: int | None = None,
     ) -> list[dict]:
-        # Keys are omitted rather than sent as null: every engine schema is
+        # Keys are omitted rather than sent as null: every command schema is
         # additionalProperties: false, so one stray key is a 400, not an ignored field.
         args: dict[str, object] = {"execution_id": execution_id, "ascending": ascending}
         if created_since is not None:
             args["created_since"] = created_since
         if limit is not None:
             args["limit"] = limit
-        return self._client.query(revision_id, "list_execution_events", engine=WORKFLOW_ENGINE, **args)[
-            "execution_events"
-        ]
+        return self._client.query(revision_id, "list_execution_events", **args)["execution_events"]
 
     def list_executions(
         self, revision_id: str, session_id: str, *, start_execution_id: str | None = None
@@ -122,24 +122,20 @@ class Api:
         args: dict[str, object] = {"session_id": session_id}
         if start_execution_id is not None:
             args["start_execution_id"] = start_execution_id
-        body = self._client.query(revision_id, "list_executions", engine=WORKFLOW_ENGINE, **args)
+        body = self._client.query(revision_id, "list_executions", **args)
         return body["executions"], body["last_execution_id"]
 
     def create_schedule(self, revision_id: str, **fields: object) -> dict:
-        return self._client.command(revision_id, "create_schedule", engine=SCHEDULER_ENGINE, **fields)["schedule"]
+        return self._client.command(revision_id, "create_schedule", **fields)["schedule"]
 
     def update_schedule(self, revision_id: str, schedule: str, **fields: object) -> dict:
-        return self._client.command(
-            revision_id, "update_schedule", engine=SCHEDULER_ENGINE, schedule_id=schedule, **fields
-        )["schedule"]
+        return self._client.command(revision_id, "update_schedule", schedule_id=schedule, **fields)["schedule"]
 
     def delete_schedule(self, revision_id: str, schedule: str) -> None:
-        self._client.command(revision_id, "delete_schedule", engine=SCHEDULER_ENGINE, schedule_id=schedule)
+        self._client.command(revision_id, "delete_schedule", schedule_id=schedule)
 
     def get_schedule(self, revision_id: str, schedule: str) -> dict:
-        return self._client.query(revision_id, "get_schedule", engine=SCHEDULER_ENGINE, schedule_id=schedule)[
-            "schedule"
-        ]
+        return self._client.query(revision_id, "get_schedule", schedule_id=schedule)["schedule"]
 
     def list_schedules(
         self, revision_id: str, *, start_schedule_id: str | None = None
@@ -153,5 +149,5 @@ class Api:
         args: dict[str, object] = {}
         if start_schedule_id is not None:
             args["start_schedule_id"] = start_schedule_id
-        body = self._client.query(revision_id, "list_schedules", engine=SCHEDULER_ENGINE, **args)
+        body = self._client.query(revision_id, "list_schedules", **args)
         return body["schedules"], body["last_schedule_id"]

{blobhub_cli-0.2.0 → blobhub_cli-0.4.0}/src/blobhub_cli/cli/app.py

@@ -156,7 +156,7 @@ def build_app() -> typer.Typer:
 
     @blob_app.command("show")
     def blob_show(blob: str = typer.Argument(..., help="Blob as '<org>/<name>', or a bare name with --org.")) -> None:
-        """Show a blob's record and the phase of its latest revision."""
+        """Show a blob's record and the phase of its default revision."""
         from blobhub_cli.commands import blob as blob_cmd
 
         blob_cmd.show(blob)
@@ -165,7 +165,7 @@ def build_app() -> typer.Typer:
     def blob_revisions(
         blob: str = typer.Argument(..., help="Blob as '<org>/<name>', or a bare name with --org."),
     ) -> None:
-        """List a blob's revisions, newest first, marking the latest."""
+        """List a blob's revisions, newest first, marking the default."""
         from blobhub_cli.commands import blob as blob_cmd
 
         blob_cmd.revisions(blob)

{blobhub_cli-0.2.0 → blobhub_cli-0.4.0}/src/blobhub_cli/codes.py

@@ -88,7 +88,6 @@ SCHEDULE_NOT_ACCESSIBLE = "SCHEDULE_NOT_ACCESSIBLE"
 
 # Advisories (warnings, not exit-worthy failures)
 DEFINITION_LIST_TRUNCATED = "DEFINITION_LIST_TRUNCATED"
-REVISION_LIST_TRUNCATED = "REVISION_LIST_TRUNCATED"
 ALLOWLIST_UNREADABLE = "ALLOWLIST_UNREADABLE"
 ALLOWLIST_STALE = "ALLOWLIST_STALE"
 ALLOWLIST_ENTRY_UNUSABLE = "ALLOWLIST_ENTRY_UNUSABLE"

{blobhub_cli-0.2.0 → blobhub_cli-0.4.0}/src/blobhub_cli/commands/blob.py

@@ -2,7 +2,7 @@
 
 Contract: each command takes a positional `<org/blob>`, resolves it through `blob.reference`, and
 returns the exact dict `--json` emits; the Typer wrappers only parse arguments.
-Invariant: none of these applies `manifest.resolver`'s workflow-shape or revision-phase gates.
+Invariant: none of these applies `manifest.resolver`'s blob-type or revision-phase gates.
 Those are right for a command about to drive a workflow blob and wrong for an inspector -- a blob
 in an unusable phase is precisely what someone runs `blob show` to diagnose.
 """
@@ -11,7 +11,6 @@ from collections.abc import Callable
 from datetime import UTC, datetime
 
 from blobhub_cli import codes, console
-from blobhub_cli import limits as limits_module
 from blobhub_cli.api.client import Client
 from blobhub_cli.api.commands import Api
 from blobhub_cli.api.errors import ApiAuthError, ApiError
@@ -45,13 +44,13 @@ def _render_show(payload: dict) -> None:
     record = payload["record"]
     print(f"{'Blob:':<12} {payload['blob']}")
     for label, key in (
-        ("Alias", "alias"), ("Id", "id"), ("Org", "org_id"), ("Domain", "domain"),
-        ("Type", "type"), ("Format", "format"), ("Visibility", "visibility"), ("Status", "status"),
+        ("Alias", "alias"), ("Id", "id"), ("Org", "org_id"), ("Type", "type"),
+        ("Visibility", "visibility"), ("Status", "status"),
     ):
         print(f"{label + ':':<12} {record.get(key, '')}")
-    revision_id = record.get("latest_revision_id")
-    revision = payload["latest_revision"]
-    print(f"{'Latest:':<12} {revision_id or '(none)'}")
+    revision_id = record.get("default_revision_id")
+    revision = payload["default_revision"]
+    print(f"{'Default:':<12} {revision_id or '(none)'}")
     if revision is None:
         # Two distinct states, and telling them apart is the difference between "mint a better key"
         # and "this blob has no revision yet".
@@ -68,7 +67,7 @@ def show(ref_text: str, *, api_factory: Callable[[Settings], Api] = _default_api
     record = _get_blob(api, ref)
 
     revision = None
-    revision_id = record.get("latest_revision_id")
+    revision_id = record.get("default_revision_id")
     if revision_id:
         try:
             revision = api.get_revision(revision_id)
@@ -79,7 +78,7 @@ def show(ref_text: str, *, api_factory: Callable[[Settings], Api] = _default_api
 
     # `blob` is the "org/name" label on every command in this group, never the record itself: one
     # key name across three sibling commands cannot carry two types and stay a machine contract.
-    payload = {"blob": ref.label(), "record": record, "latest_revision": revision}
+    payload = {"blob": ref.label(), "record": record, "default_revision": revision}
     console.result(payload, _render_show)
     return payload
 
@@ -89,7 +88,7 @@ def _render_revisions(payload: dict) -> None:
         return
     print(f"{'':2}{'REVISION':<38} {'PHASE':<9} {'STATUS':<11} {'CREATED':<26} COMMENT")
     for item in payload["revisions"]:
-        marker = "* " if item["latest"] else "  "
+        marker = "* " if item["default"] else "  "
         print(f"{marker}{item['id']:<38} {item['phase']:<9} {item['status']:<11} "
               f"{item['created_at']:<26} {item['comment']}")
 
@@ -98,41 +97,36 @@ def revisions(ref_text: str, *, api_factory: Callable[[Settings], Api] = _defaul
     ref, resolved = _resolve_ref(ref_text, "blob revisions")
     api = api_factory(resolved)
 
-    # The listing does not report which revision is latest, so the blob record is required, not
+    # The listing does not report which revision is the default, so the blob record is required, not
     # merely enrichment.
     record = _get_blob(api, ref)
-    latest_revision_id = record.get("latest_revision_id")
-    found = api.list_revisions(ref.org, ref.name)
-
-    maximum = limits_module.maximum(
-        limits_module.read_optional(api, ref.org, ref.name), limits_module.LIMIT_REVISIONS_PER_BLOB
-    )
-    if maximum is not None and len(found) >= maximum:
-        console.advisory(
-            codes.REVISION_LIST_TRUNCATED,
-            f"the revision listing returned {len(found)} revision(s), matching the blob's configured "
-            f"maximum of {maximum} -- the platform cannot page this listing, so the result may be "
-            "missing revisions it silently dropped",
-        )
-
-    # Newest first: DynamoDB returns index order, which is neither documented nor useful, and the
-    # reason to run this command is almost always to find the newest revision.
-    items = sorted(
-        (
-            {
-                "id": item["id"],
-                "phase": item.get("phase", ""),
-                "status": item.get("status", ""),
-                "created_at": item.get("created_at", ""),
-                "comment": item.get("comment", ""),
-                "parent_id": item.get("parent_id"),
-                "latest": item["id"] == latest_revision_id,
-            }
-            for item in found
-        ),
-        key=lambda item: item["created_at"],
-        reverse=True,
-    )
+    default_revision_id = record.get("default_revision_id")
+
+    # Drained page by page, terminating on the cursor and never on a short page -- the same rule
+    # `scheduler/schedules.py`'s `load_all` follows, and for the same reason: the cursor is absent
+    # only once the query is exhausted, so a final page can legitimately be exactly full.
+    found: list[dict] = []
+    cursor: str | None = None
+    while True:
+        page, cursor = api.list_revisions(ref.org, ref.name, cursor=cursor)
+        found.extend(page)
+        if cursor is None:
+            break
+
+    # Order comes from the route, which queries the `blob_id-created_at` index newest-first and
+    # documents that. Re-sorting a complete, ordered result could only reorder ties.
+    items = [
+        {
+            "id": item["id"],
+            "phase": item.get("phase", ""),
+            "status": item.get("status", ""),
+            "created_at": item.get("created_at", ""),
+            "comment": item.get("comment", ""),
+            "parent_id": item.get("parent_id"),
+            "default": item["id"] == default_revision_id,
+        }
+        for item in found
+    ]
 
     payload = {"blob": ref.label(), "revisions": items}
     console.result(payload, _render_revisions)

{blobhub_cli-0.2.0 → blobhub_cli-0.4.0}/src/blobhub_cli/commands/execute.py

@@ -30,7 +30,8 @@ from blobhub_cli.workflow import definitions, executions
 
 # blobhub-web serves the routes `Navigation.workflowPath` builds (src/context/nav.js) from
 # blobhub.io; the path itself -- `/{org_id}/{blob_id}/debugger/{session_id}/{execution_id}` -- is
-# reproduced below rather than assumed (spec §1.4).
+# reproduced below rather than assumed (spec §1.4). The revision rides as `?revision=`, never in the
+# path: that path form is deleted, and the slot it used is the debugger's own.
 DEBUGGER_BASE_URL = "https://blobhub.io"
 
 
@@ -85,7 +86,13 @@ def execute(
     definition_id = set_.remote[(entry.category, entry.alias)].id
     execution = api.create_execution(target.revision_id, session_id, definition_id=definition_id)
 
-    url = f"{DEBUGGER_BASE_URL}/{target.org_id}/{target.blob_id}/debugger/{session_id}/{execution['id']}"
+    # `?revision=` carries the RESOLVED id, never the manifest's symbol: an execution lives in one
+    # revision, and a link without it opens on whatever revision the reader last chose, where this
+    # session does not exist. blobhub-web drops the parameter itself once it names the default.
+    url = (
+        f"{DEBUGGER_BASE_URL}/{target.org_id}/{target.blob_id}/debugger/{session_id}/{execution['id']}"
+        f"?revision={target.revision_id}"
+    )
     # Launching a browser is a side effect, not output -- there is no `console.stream()` call this
     # could route through -- so it is the one place this command asks `console.json_mode()` directly.
     if open_browser and not console.json_mode():

{blobhub_cli-0.2.0 → blobhub_cli-0.4.0}/src/blobhub_cli/commands/scheduler.py

@@ -58,7 +58,7 @@ from blobhub_cli.config import settings
 from blobhub_cli.config.settings import Settings
 from blobhub_cli.exit import CliExit
 from blobhub_cli.formats import io
-from blobhub_cli.manifest import resolver, scheduler
+from blobhub_cli.manifest import base, resolver, scheduler
 from blobhub_cli.scheduler import references, schedules
 
 # Spec §8: the real workflow_executions_per_session maximum needs an admin key most callers don't
@@ -79,7 +79,7 @@ def _render_ls(payload: dict) -> None:
     print(f"{'':2}{'ALIAS':<30} {'ID':<38} {'REPEAT':<15} {'ENABLED':<8} {'STATE':<10} WORKFLOW")
     for item in payload["schedules"]:
         # `*` marks a schedule the manifest covers -- the same marker `workflow ls` and
-        # `_render_revisions` (`commands/blob.py`) use for coverage/latest, so this table reads like
+        # `_render_revisions` (`commands/blob.py`) use for coverage/default, so this table reads like
         # its siblings at a glance.
         marker = "* " if item["in_manifest"] else "  "
         # A schedule the platform stored with no alias has nothing to put in this column; the ID
@@ -136,15 +136,12 @@ def ls(
     return payload
 
 
-def _reversed_entry(api: Api, record: dict, *, manifest_org_id: str, original_revision: str) -> dict:
+def _reversed_entry(api: Api, record: dict, *, manifest_org_id: str) -> dict:
     # Built as a plain dict, not a `manifest.scheduler.ScheduleEntry` -- `pull` writes a document
     # through `formats.io`, and the dataclass exists to be parsed *from* a manifest, not serialized
     # back into one. Field order here matches the manifest sample in the spec, so a pulled file reads
     # the same way a hand-authored one does.
-    target = references.reverse_target(
-        api, record["invocation_target"], manifest_org_id=manifest_org_id,
-        original_revision=original_revision,
-    )
+    target = references.reverse_target(api, record["invocation_target"], manifest_org_id=manifest_org_id)
     target_doc = {
         "type": target.type,
         "blob": target.blob,
@@ -206,21 +203,11 @@ def pull(
     # firing, and dropping it silently is how an operator ends up with a schedule they cannot see.
     unmanageable = [record["id"] for record in records if record.get("alias") is None]
 
-    # Reversal must reproduce the symbol the entry actually wrote, and a stored `invocation_target`
-    # records only the resolved id -- so the manifest's own entries are the sole surviving evidence
-    # of whether a target revision was written as `latest` or deliberately pinned. Matched by alias,
-    # the same identity `deploy` decides create-versus-update on; a schedule with no manifest entry
-    # has no original symbol to reproduce, and `latest` stays the right default for it.
-    original_revisions = {entry.alias: entry.target.revision for entry in manifest.schedules}
-
     # Sorted by alias, like `ls`'s rows: deterministic output a diff or a script can rely on, not an
     # accident of `list_schedules`' newest-first paging order.
     entries = sorted(
         (
-            _reversed_entry(
-                api, record, manifest_org_id=target.org_id,
-                original_revision=original_revisions.get(record["alias"], "latest"),
-            )
+            _reversed_entry(api, record, manifest_org_id=target.org_id)
             for record in records if record.get("alias") is not None
         ),
         key=lambda entry: entry["alias"],
@@ -276,8 +263,12 @@ def _local_fields(
         "enabled": entry.enabled,
         "start_date": entry.start_date,
         "end_date": entry.end_date,
-        "target.revision": target.revision_id,
-        "target.session": target.session_id,
+        # The symbols the platform stores, not the ids they resolved to. `target.blob` is not
+        # cosmetic: under `revision: default` the revision symbol is identical for every blob, so
+        # without it a manifest retargeted at a different blob compares equal and is never written.
+        "target.blob": target.blob_id,
+        "target.revision": target.revision_ref,
+        "target.session": _stored_session(target),
         "target.workflow": target.workflow_alias,
         "target.input_data": target.input_data,
         "target.description": target.description,
@@ -298,8 +289,9 @@ def _remote_fields(record: dict) -> dict:
         "enabled": record["enabled"],
         "start_date": record.get("start_date"),
         "end_date": record.get("end_date"),
-        "target.revision": invocation_target["revision_id"],
-        "target.session": invocation_target["session_id"],
+        "target.blob": invocation_target["blob_id"],
+        "target.revision": invocation_target["revision"],
+        "target.session": invocation_target["session"],
         "target.workflow": invocation_target["workflow_alias"],
         "target.input_data": invocation_target.get("input_data", []),
         "target.description": invocation_target.get("description"),
@@ -373,9 +365,13 @@ def diff(
 
 
 def _invocation_target(resolved: references.ResolvedTarget) -> dict:
+    # INVOCATION_TARGET_SCHEMA is additionalProperties: false and has no `org_id` -- the platform
+    # derives the org from the blob. `revision` is the manifest's own symbol, not the id it resolved
+    # to, because storing the id is exactly the pinning a following target exists to avoid.
     target: dict[str, object] = {
-        "revision_id": resolved.revision_id,
-        "session_id": resolved.session_id,
+        "blob_id": resolved.blob_id,
+        "revision": resolved.revision_ref,
+        "session": _stored_session(resolved),
         "workflow_alias": resolved.workflow_alias,
         "input_data": resolved.input_data,
     }
@@ -384,8 +380,20 @@ def _invocation_target(resolved: references.ResolvedTarget) -> dict:
     return target
 
 
+def _stored_session(target: references.PreviewedTarget | references.ResolvedTarget) -> str | None:
+    """What the platform ends up holding in `invocation_target.session` for this target.
+
+    A following target keeps its alias -- `_resolve_invocation_target_blob` writes the resolved id
+    back only for a pinned one. Sending what the platform will store is what keeps a second `deploy`
+    of an unchanged manifest a no-op rather than a perpetual update.
+    """
+    if target.revision_ref == base.REVISION_DEFAULT:
+        return target.session_ref
+    return target.session_id
+
+
 def _schedule_fields(entry: scheduler.ScheduleEntry, resolved: references.ResolvedTarget) -> dict:
-    # Keys omitted rather than sent as null: every engine schema is additionalProperties: false
+    # Keys omitted rather than sent as null: every command schema is additionalProperties: false
     # (api/commands.py), so an explicit start_date/end_date: null would be a 400, not an ignored field.
     # invocation_target_type is a TOP-LEVEL sibling of invocation_target in CREATE_SCHEDULE_SCHEMA /
     # UPDATE_SCHEDULE_SCHEMA (spec §1.2) and required on create -- omitting it 400s every real

{blobhub_cli-0.2.0 → blobhub_cli-0.4.0}/src/blobhub_cli/commands/workflow.py

@@ -654,7 +654,7 @@ def _render_ls(payload: dict) -> None:
     print(f"{'':2}{'CATEGORY':<10} {'ALIAS':<30} ID")
     for item in payload["definitions"]:
         # `*` marks a definition the manifest covers -- the same marker `_render_revisions`
-        # (`commands/blob.py`) uses for "latest", so this table reads like its sibling at a glance.
+        # (`commands/blob.py`) uses for "default", so this table reads like its sibling at a glance.
         marker = "* " if item["in_manifest"] else "  "
         print(f"{marker}{item['category']:<10} {item['alias']:<30} {item['id']}")