Skip to main content

v2.17.0

Release notes for orun v2.17.0.

This release graduates the remote state backend into the Orun Platform client: a credential-agnostic CLI that authenticates a session, links a repo to an org/project, coordinates runs against a hosted backend, and pushes the service catalog into an org-global browser — all over the same content-addressed object model orun already records on disk. The cockpit also lands its Catalog surface as the single home for browse, run, and history.

Highlights​

  • Orun Cloud client (OC0–OC6). The CLI now speaks the full hosted-backend contract. orun auth manages a local CLI session (browser + headless device login, rotating refresh tokens, OS-keychain storage); orun cloud links the current repo to an org/project and caches the scope. orun run --remote-state coordinates execution against the backend — leases, live log streaming, and a fail-fast path before any backend call when you are not logged in or the repo is not linked.
  • Credential-agnostic CI. Inside GitHub Actions, --remote-state exchanges the workflow's OIDC token for a scoped backend session — no PAT, no stored secret. The OIDC-resolved org/project fills in any scope you did not pass explicitly, so the same command works locally and in CI.
  • orun catalog push. Sync the resolved catalog snapshot to Orun Cloud and advance the catalog head, recording the source commit. The upload is a content set-difference (only the blobs the server lacks), so a re-push transfers ~zero bytes. orun catalog refresh --push does both in one step.
  • orun run --local escape hatch. Force local filesystem state for a single run, overriding any remote-state config/flags — the safe fallback when the backend is down.
  • orun logs --follow. Live-tail a job's log from the backend (--remote-state --job <id>), polling from a fromSeq cursor until the job completes.
  • Cockpit Catalog surface. The cockpit's Catalog replaces the old Components surface as one home for browse, run, history, and the changed/affected overlay. A two-line header carries source context (repo, branch, commit) alongside an animated brand mark, and the live step-log view no longer leaves ghost rows while streaming.

Orun Cloud: the platform client​

The remote state backend is no longer a single-tenant side door — it is the client half of the Orun Platform. Three commands frame the lifecycle:

CommandWhat it does
orun auth loginBrowser or --device headless login. Stores only Orun-issued access/refresh tokens (never a GitHub PAT) in the OS keychain, falling back to ~/.orun/credentials.json (0600).
orun cloud linkResolves the git remote → picks/creates an org/project → caches the scope in ~/.orun/config.yaml. Non-interactive --org/--project for CI.
orun run --remote-stateCoordinates the run against the backend: claims work under the linked scope, holds a lease (server-driven interval; lease_lost preempts), and streams logs live.

Auth and scope resolution follow a single precedence everywhere: explicit flag → environment → cached link → (in CI) the OIDC-exchanged scope. See orun auth and orun cloud.

Credential-agnostic CI​

In GitHub Actions, the CLI requests the workflow's OIDC token and exchanges it at the backend for a short-lived, org/project-scoped session. There is no long-lived secret to provision: the same orun run --remote-state (or orun catalog push) that works at your desk works unchanged in CI, with the OIDC-resolved scope filling in anything you left unset.

Run coordination​

orun run --remote-state delegates DAG ordering to the backend. Each matrix job runs orun run --remote-state --job <id>, claims its work under a lease, polls until its dependencies complete, and streams step logs to the backend as it goes. When the backend is unreachable, orun run --local forces local filesystem state so a run is never blocked on the platform.

Publishing the catalog​

orun catalog push syncs the locally resolved catalogs/current closure to Orun Cloud and advances the catalog head, recording the source git commit. The org-global catalog browser reflects the new snapshot within seconds.

orun catalog refresh           # (re)resolve the workspace
orun catalog push              # upload the closure + advance the head
orun catalog refresh --push    # both in one step
orun catalog push --environment staging   # advance a named environment head

Because the object model is content-addressed, the upload is a set difference — only the blobs the server is missing are transferred, and the head advance fails closed if the closure was not uploaded first. See orun catalog.

Object-model transport​

The same object graph orun keeps under .orun/objectmodel/ now has HTTP transports for its ObjectStore and RefStore, so a remote backend is a drop-in endpoint behind the existing ModelReader read seam. Large objects upload via a multipart sub-protocol, and the remote log pipeline spills to file under backpressure. The on-disk schema is unchanged — remote is just another driver.

Cockpit​

  • Catalog replaces Components. The Catalog surface is now the single home for browsing entities, launching component-scoped runs, viewing history, and the changed/affected overlay — the standalone Components surface is gone.
  • Two-line header. The cockpit header now shows source context (repository, branch, commit) on a second line, next to an animated brand mark.
  • Steadier live logs. The streaming step-log view was stabilized — no more ghost rows while a run streams and you scroll.

Also in this release​

  • Work plane (internal, W0–W4). Foundations for orun-work — a content-addressed system of record for delivery: PR-webhook ingestion, the delivery-decision core, and content-addressed sealing. Internal for now; no user-facing CLI surface yet.
  • Cross-language golden vectors. objgolden publishes authoritative cross-language golden vectors for the object model, so non-Go readers can be validated byte-for-byte against the canonical encoder.

References​